@pmelab/gtd 40.0.0 → 41.0.0

package/.claude-plugin/plugin.json

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

@@ -506,8 +506,9 @@ noted in steps 3 and 4 below.
    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. Before any escalation or red-baseline stop the suite
-   runs once more; a pass there continues without you and is recorded as
+   attempt anywhere new. A loop the retry judge still calls progress at the cap
+   gets one extra fix turn first. 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)).
 

package/dist/chunks/{reserved-Qt5FM6Ia.mjs → reserved-Ch4LLrEj.mjs}

@@ -1632,7 +1632,7 @@ const retryQuestion = (comparable) => comparable ? {
 	instructions: "state carries tailsNotComparable: one of the two check reports came back empty. There is nothing to compare here; answer from criteria alone. `identical` is FORBIDDEN here.",
 	criteria: "new-failure: a materially different failure than before. progress: still red, but closer to green — the default if genuinely unsure."
 };
-const sameFailure = async (previous, current) => {
+const compare = async (previous, current) => {
 	const comparable = current.trim() !== "" && previous.trim() !== "";
 	const { answers, truncated } = await judge("health.judge", {
 		questions: [retryQuestion(comparable)],
@@ -1643,7 +1643,10 @@ const sameFailure = async (previous, current) => {
 		message: healthJudgeMessage(),
 		label: "Judging the retry"
 	});
-	return comparable && truncated.length === 0 && answered(answers.verdict, "identical", numeric(vars.judgeIdenticalMinP, Infinity));
+	if (!comparable || truncated.length > 0) return void 0;
+	const minP = numeric(vars.judgeIdenticalMinP, Infinity);
+	if (answered(answers.verdict, "identical", minP)) return "identical";
+	return answered(answers.verdict, "progress", minP) ? "progress" : void 0;
 };
 const healthSweep = (options) => [ESCALATION, ...options.sweepOnGreen ?? []];
 const runSuite = (options) => check("health.check", env.testCommand ?? "", {
@@ -1654,7 +1657,8 @@ const runSuite = (options) => check("health.check", env.testCommand ?? "", {
 /**
 * 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. An escalation re-runs the suite once
+* identical to the previous round's. A judge calling it progress at the cap
+* buys one extra fix per run of fixes. 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), {
@@ -1662,7 +1666,7 @@ const healthy = (fix, options = {}) => healthy$1(guarded(fix, options.guard), {
 	report: FEEDBACK,
 	fixCap: 3,
 	fixesSoFar: options.fixesSoFar ?? 0,
-	sameFailure,
+	compare,
 	escalations: options.escalations ?? { rounds: 0 },
 	recheck: () => recheck("health.recheck", "health.check", { sweepOnGreen: healthSweep(options) }),
 	escalation: guardedSteps(options.guard, options.describeGuard, options.guardRests, options.rules)

package/dist/chunks/{tail-tAHx_AHe.mjs → tail-lY1UmJrU.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-Qt5FM6Ia.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-Ch4LLrEj.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/workflow-kit.mjs

@@ -22,13 +22,33 @@ const recheckReport = async (health) => {
 	if (health.recheck === void 0) return void 0;
 	return await health.recheck() || stripStamp(read(health.report) ?? "");
 };
+/** Escalate unless the re-check passes: `true` then, else the report the next round compares against. */
+const escalated = async (health, current) => {
+	const rechecked = await recheckReport(health);
+	if (rechecked === true) {
+		health.escalations.rounds = 0;
+		return true;
+	}
+	await escalation(health.escalations, health.escalation);
+	return rechecked ?? current;
+};
+const nextMove = async (health, fixes, cap, previous, current) => {
+	const capped = fixes >= cap;
+	if (capped && cap > health.fixCap) return "escalate";
+	const verdict = previous === void 0 ? void 0 : await health.compare(previous, current);
+	if (capped && verdict === "progress") return "extend";
+	return verdict === "identical" || capped ? "escalate" : void 0;
+};
 /**
 * 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, unless `recheck` passes.
+* first once `fixCap` fixes are spent, or `compare` calls the failure
+* identical to the previous round's, unless `recheck` passes. A round that
+* reaches the cap while `compare` calls it progress raises the cap by one fix,
+* once per run of fixes between escalations.
 */
 const healthy = async (fix, health) => {
 	let fixes = health.fixesSoFar ?? 0;
+	let cap = health.fixCap;
 	let previous;
 	for (;;) {
 		if (await health.check()) {
@@ -36,17 +56,15 @@ const healthy = async (fix, health) => {
 			return;
 		}
 		const current = stripStamp(read(health.report) ?? "");
-		const stuck = previous !== void 0 && await health.sameFailure(previous, current);
+		const move = await nextMove(health, fixes, cap, 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);
+		if (move === "extend") cap++;
+		else if (move === "escalate") {
+			const after = await escalated(health, current);
+			if (after === true) return;
+			previous = after;
 			fixes = 0;
+			cap = health.fixCap;
 		}
 		fixes++;
 		await fix();

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-Qt5FM6Ia.mjs";
-import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-tAHx_AHe.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-Ch4LLrEj.mjs";
+import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-lY1UmJrU.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-Qt5FM6Ia.mjs";
-import { a as refusePendingHandOff, i as isOptionalObject, n as closeReview, o as tail } from "../chunks/tail-tAHx_AHe.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-Ch4LLrEj.mjs";
+import { a as refusePendingHandOff, i as isOptionalObject, n as closeReview, o as tail } from "../chunks/tail-lY1UmJrU.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-Qt5FM6Ia.mjs";
-import { r as handOffTail, t as REVIEW_ORIG } from "../chunks/tail-tAHx_AHe.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-Ch4LLrEj.mjs";
+import { r as handOffTail, t as REVIEW_ORIG } from "../chunks/tail-lY1UmJrU.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-Qt5FM6Ia.mjs";
-import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-tAHx_AHe.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-Ch4LLrEj.mjs";
+import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-lY1UmJrU.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-Qt5FM6Ia.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-Ch4LLrEj.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

@@ -456,13 +456,33 @@ const recheckReport = async (health) => {
 	if (health.recheck === void 0) return void 0;
 	return await health.recheck() || stripStamp(read(health.report) ?? "");
 };
+/** Escalate unless the re-check passes: `true` then, else the report the next round compares against. */
+const escalated = async (health, current) => {
+	const rechecked = await recheckReport(health);
+	if (rechecked === true) {
+		health.escalations.rounds = 0;
+		return true;
+	}
+	await escalation$1(health.escalations, health.escalation);
+	return rechecked ?? current;
+};
+const nextMove = async (health, fixes, cap, previous, current) => {
+	const capped = fixes >= cap;
+	if (capped && cap > health.fixCap) return "escalate";
+	const verdict = previous === void 0 ? void 0 : await health.compare(previous, current);
+	if (capped && verdict === "progress") return "extend";
+	return verdict === "identical" || capped ? "escalate" : void 0;
+};
 /**
 * 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, unless `recheck` passes.
+* first once `fixCap` fixes are spent, or `compare` calls the failure
+* identical to the previous round's, unless `recheck` passes. A round that
+* reaches the cap while `compare` calls it progress raises the cap by one fix,
+* once per run of fixes between escalations.
 */
 const healthy$1 = async (fix, health) => {
 	let fixes = health.fixesSoFar ?? 0;
+	let cap = health.fixCap;
 	let previous;
 	for (;;) {
 		if (await health.check()) {
@@ -470,17 +490,15 @@ const healthy$1 = async (fix, health) => {
 			return;
 		}
 		const current = stripStamp(read(health.report) ?? "");
-		const stuck = previous !== void 0 && await health.sameFailure(previous, current);
+		const move = await nextMove(health, fixes, cap, 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);
+		if (move === "extend") cap++;
+		else if (move === "escalate") {
+			const after = await escalated(health, current);
+			if (after === true) return;
+			previous = after;
 			fixes = 0;
+			cap = health.fixCap;
 		}
 		fixes++;
 		await fix();
@@ -18448,7 +18466,7 @@ const retryQuestion = (comparable) => comparable ? {
 	instructions: "state carries tailsNotComparable: one of the two check reports came back empty. There is nothing to compare here; answer from criteria alone. `identical` is FORBIDDEN here.",
 	criteria: "new-failure: a materially different failure than before. progress: still red, but closer to green — the default if genuinely unsure."
 };
-const sameFailure = async (previous, current) => {
+const compare$1 = async (previous, current) => {
 	const comparable = current.trim() !== "" && previous.trim() !== "";
 	const { answers, truncated } = await judge("health.judge", {
 		questions: [retryQuestion(comparable)],
@@ -18459,7 +18477,10 @@ const sameFailure = async (previous, current) => {
 		message: healthJudgeMessage(),
 		label: "Judging the retry"
 	});
-	return comparable && truncated.length === 0 && answered(answers.verdict, "identical", numeric(vars.judgeIdenticalMinP, Infinity));
+	if (!comparable || truncated.length > 0) return void 0;
+	const minP = numeric(vars.judgeIdenticalMinP, Infinity);
+	if (answered(answers.verdict, "identical", minP)) return "identical";
+	return answered(answers.verdict, "progress", minP) ? "progress" : void 0;
 };
 const healthSweep = (options) => [ESCALATION, ...options.sweepOnGreen ?? []];
 const runSuite = (options) => check("health.check", env.testCommand ?? "", {
@@ -18470,7 +18491,8 @@ const runSuite = (options) => check("health.check", env.testCommand ?? "", {
 /**
 * 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. An escalation re-runs the suite once
+* identical to the previous round's. A judge calling it progress at the cap
+* buys one extra fix per run of fixes. 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), {
@@ -18478,7 +18500,7 @@ const healthy = (fix, options = {}) => healthy$1(guarded(fix, options.guard), {
 	report: FEEDBACK,
 	fixCap: 3,
 	fixesSoFar: options.fixesSoFar ?? 0,
-	sameFailure,
+	compare: compare$1,
 	escalations: options.escalations ?? { rounds: 0 },
 	recheck: () => recheck("health.recheck", "health.check", { sweepOnGreen: healthSweep(options) }),
 	escalation: guardedSteps(options.guard, options.describeGuard, options.guardRests, options.rules)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "40.0.0",
+  "version": "41.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/workflow-kit/health.ts

@@ -32,6 +32,8 @@ export const untilSettled = async (
   }
 }
 
+export type RetryVerdict = "identical" | "progress"
+
 export interface Health {
   /** One counted run of the suite; resolves `true` when green. */
   readonly check: () => Promise<boolean>
@@ -39,8 +41,8 @@ export interface Health {
   readonly report: string
   readonly fixCap: number
   readonly fixesSoFar?: number
-  /** Whether two consecutive red reports are the same failure; `true` escalates at once. */
-  readonly sameFailure: (previous: string, current: string) => Promise<boolean>
+  /** How a red report compares to the previous round's: `identical` escalates at once, `progress` at the cap earns one extra fix. */
+  readonly compare: (previous: string, current: string) => Promise<RetryVerdict | undefined>
   /** Shared with other callers in the same run of red checks. */
   readonly escalations: EscalationCount
   readonly escalation: EscalationSteps
@@ -58,13 +60,42 @@ const recheckReport = async (health: Health): Promise<true | string | undefined>
   return (await health.recheck()) || stripStamp(read(health.report) ?? "")
 }
 
+/** Escalate unless the re-check passes: `true` then, else the report the next round compares against. */
+const escalated = async (health: Health, current: string): Promise<true | string> => {
+  const rechecked = await recheckReport(health)
+  if (rechecked === true) {
+    health.escalations.rounds = 0
+    return true
+  }
+  await escalation(health.escalations, health.escalation)
+  return rechecked ?? current
+}
+
+const nextMove = async (
+  health: Health,
+  fixes: number,
+  cap: number,
+  previous: string | undefined,
+  current: string,
+): Promise<"extend" | "escalate" | undefined> => {
+  const capped = fixes >= cap
+  // Past a raised cap the loop escalates whatever the judge would answer.
+  if (capped && cap > health.fixCap) return "escalate"
+  const verdict = previous === undefined ? undefined : await health.compare(previous, current)
+  if (capped && verdict === "progress") return "extend"
+  return verdict === "identical" || capped ? "escalate" : undefined
+}
+
 /**
  * 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, unless `recheck` passes.
+ * first once `fixCap` fixes are spent, or `compare` calls the failure
+ * identical to the previous round's, unless `recheck` passes. A round that
+ * reaches the cap while `compare` calls it progress raises the cap by one fix,
+ * once per run of fixes between escalations.
  */
 export const healthy = async (fix: () => Promise<void>, health: Health): Promise<void> => {
   let fixes = health.fixesSoFar ?? 0
+  let cap = health.fixCap
   let previous: string | undefined
   for (;;) {
     if (await health.check()) {
@@ -72,17 +103,15 @@ export const healthy = async (fix: () => Promise<void>, health: Health): Promise
       return
     }
     const current = stripStamp(read(health.report) ?? "")
-    const stuck = previous !== undefined && (await health.sameFailure(previous, current))
+    const move = await nextMove(health, fixes, cap, 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)
+    if (move === "extend") cap++
+    else if (move === "escalate") {
+      const after = await escalated(health, current)
+      if (after === true) return
+      previous = after
       fixes = 0
+      cap = health.fixCap
     }
     fixes++
     await fix()

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

@@ -116,3 +116,33 @@ describe("healthy describeGuard", () => {
     ).rejects.toThrow("guarded: nope")
   })
 })
+
+describe("healthy at the fix cap", () => {
+  // Blank reports are not comparable; at an 8-byte budget the cut trims both.
+  it.each([
+    ["could not compare", "", (n: number) => "\n".repeat(n)],
+    ["saw only cut", `, judgeBudgetBytes: "8"`, (n: number) => `a long failing report ${n}\n`],
+  ])("grants no extra turn on progress the judge %s", async (_, extra, report) => {
+    let runs = 0
+    const repo = testRepo({
+      workflow: [
+        `import { healthy } from "@pmelab/gtd/workflows"`,
+        `import { agent } from "@pmelab/gtd/flows"`,
+        `export const defaults = { judgeIdenticalMinP: "0.7"${extra} }`,
+        `export const held = async () => { await agent("first", "go"); await healthy(() => agent("fix", "go")) }`,
+        `export default held`,
+      ].join("\n"),
+      env: { GTD_TEST_COMMAND: "true" },
+    })
+    await repo.start("held")
+    const rest = await repo.drive({
+      first: (_, r) => r.write("start", "1\n"),
+      "health.check": (_, r) => r.write(".gtd/FEEDBACK.md", report(++runs)),
+      "health.judge": () => '[{"id":"verdict","answer":"progress","p":0.9}]',
+      fix: (_, r) => r.write("f", `${runs}\n`),
+      "health.recheck": (_, r) => r.write(".gtd/FEEDBACK.md", "red again\n"),
+    })
+    expect(rest.state).toBe("health.describe")
+    expect(repo.subjects().filter((s) => s.startsWith("gtd(agent): fix")).length).toBe(3)
+  })
+})

package/src/workflows/shared/health.ts

@@ -105,7 +105,10 @@ export const retryQuestion = (comparable: boolean): JudgeQuestion =>
           "new-failure: a materially different failure than before. progress: still red, but closer to green — the default if genuinely unsure.",
       }
 
-const sameFailure = async (previous: string, current: string): Promise<boolean> => {
+const compare = async (
+  previous: string,
+  current: string,
+): Promise<kit.RetryVerdict | undefined> => {
   const comparable = current.trim() !== "" && previous.trim() !== ""
   const { answers, truncated } = await judge("health.judge", {
     questions: [retryQuestion(comparable)],
@@ -113,12 +116,11 @@ const sameFailure = async (previous: string, current: string): Promise<boolean>
     message: t.healthJudgeMessage(),
     label: "Judging the retry",
   })
-  // Evidence the budget cut can make two different reports look alike: never sameness.
-  return (
-    comparable &&
-    truncated.length === 0 &&
-    answered(answers.verdict, "identical", numeric(vars.judgeIdenticalMinP, Infinity))
-  )
+  // Evidence the budget cut can make two different reports look alike: neither sameness nor progress.
+  if (!comparable || truncated.length > 0) return undefined
+  const minP = numeric(vars.judgeIdenticalMinP, Infinity)
+  if (answered(answers.verdict, "identical", minP)) return "identical"
+  return answered(answers.verdict, "progress", minP) ? "progress" : undefined
 }
 
 export interface HealthOptions {
@@ -153,7 +155,8 @@ const runSuite = (options: HealthOptions): Promise<boolean> =>
 /**
  * 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. An escalation re-runs the suite once
+ * identical to the previous round's. A judge calling it progress at the cap
+ * buys one extra fix per run of fixes. 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> =>
@@ -162,7 +165,7 @@ export const healthy = (fix: () => Promise<void>, options: HealthOptions = {}):
     report: FEEDBACK,
     fixCap: FIX_CAP,
     fixesSoFar: options.fixesSoFar ?? 0,
-    sameFailure,
+    compare,
     escalations: options.escalations ?? { rounds: 0 },
     recheck: () =>
       recheck("health.recheck", "health.check", { sweepOnGreen: healthSweep(options) }),

package/src/workflows/shared/progress.feature

@@ -0,0 +1,124 @@
+@inmem
+Feature: a fix loop still making progress at the cap gets one extra turn
+
+  `healthy` escalates once three fix turns are spent. When `health.judge`
+  calls that round progress — still red, but closer to green — with at least
+  `judgeIdenticalMinP` confidence, one more fix runs first, once per run of
+  fixes. The round after it escalates without asking the judge. Any other
+  verdict escalates at the cap as before.
+
+  Background:
+    Given a gtd config with:
+      """
+      import { healthy } from "@pmelab/gtd/workflows"
+      import { agent } from "@pmelab/gtd/flows"
+
+      export const defaults = { judgeIdenticalMinP: "0.7" }
+      export const held = async () => {
+        await agent("first", "go")
+        await healthy(() => agent("fix", "go"))
+      }
+      export default held
+      """
+    And step "first" writes "src/a.ts" with:
+      """
+      export const a = 1
+      """
+    And step "health.check" writes ".gtd/FEEDBACK.md" with:
+      """
+      tests failing
+      """
+    And step "fix" deletes ".gtd/FEEDBACK.md"
+    And step "health.recheck" writes ".gtd/FEEDBACK.md" with:
+      """
+      tests still failing
+      """
+
+  Scenario: progress at the cap buys exactly one extra fix turn
+    Given judge step "health.judge" answers:
+      """
+      [{"id":"verdict","answer":"progress","p":0.9}]
+      """
+    When gtd starts workflow "held"
+    And the process is driven
+    Then the process rests at "health.describe"
+    And the commit subjects end with:
+      """
+      gtd(agent): first → health.check
+      gtd(check): health.check → fix
+      gtd(agent): fix → health.check
+      gtd(check): health.check → health.judge
+      gtd(judge): health.judge → fix
+      gtd(agent): fix → health.check
+      gtd(check): health.check → health.judge
+      gtd(judge): health.judge → fix
+      gtd(agent): fix → health.check
+      gtd(check): health.check → health.judge
+      gtd(judge): health.judge → fix
+      gtd(agent): fix → health.check
+      gtd(check): health.check → health.recheck
+      gtd(check): health.recheck → health.describe
+      """
+
+  Scenario Outline: <verdict> at <p> escalates at the cap without an extra turn
+    Given judge step "health.judge" answers:
+      """
+      [{"id":"verdict","answer":"<verdict>","p":<p>}]
+      """
+    When gtd starts workflow "held"
+    And the process is driven
+    Then the process rests at "health.describe"
+    And the commit subjects end with:
+      """
+      gtd(agent): first → health.check
+      gtd(check): health.check → fix
+      gtd(agent): fix → health.check
+      gtd(check): health.check → health.judge
+      gtd(judge): health.judge → fix
+      gtd(agent): fix → health.check
+      gtd(check): health.check → health.judge
+      gtd(judge): health.judge → fix
+      gtd(agent): fix → health.check
+      gtd(check): health.check → health.judge
+      gtd(judge): health.judge → health.recheck
+      gtd(check): health.recheck → health.describe
+      """
+
+    Examples:
+      | verdict     | p   |
+      | new-failure | 0.9 |
+      | progress    | 0.5 |
+
+  Scenario: a person's escalation stop starts a new run of fixes with its own extra turn
+    Given judge step "health.judge" answers:
+      """
+      [{"id":"verdict","answer":"progress","p":0.9}]
+      """
+    And step "health.describe" writes ".gtd/ESCALATION.md" with:
+      """
+      try something else
+      """
+    And step "health.stop" writes "NOTES.md" with:
+      """
+      narrowed
+      """
+    When gtd starts workflow "held"
+    And the process is driven
+    Then the process rests at "health.exhausted"
+    And the commit subjects end with:
+      """
+      gtd(agent): health.describe → health.stop
+      gtd(human): health.stop → fix
+      gtd(agent): fix → health.check
+      gtd(check): health.check → health.judge
+      gtd(judge): health.judge → fix
+      gtd(agent): fix → health.check
+      gtd(check): health.check → health.judge
+      gtd(judge): health.judge → fix
+      gtd(agent): fix → health.check
+      gtd(check): health.check → health.judge
+      gtd(judge): health.judge → fix
+      gtd(agent): fix → health.check
+      gtd(check): health.check → health.recheck
+      gtd(check): health.recheck → health.exhausted
+      """