@pmelab/gtd 53.0.0 → 54.0.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "gtd",
-  "version": "53.0.0",
+  "version": "54.0.0",
   "description": "Drive the gtd loop inside Claude Code: agent turns run as subagents, gtd decides every beat",
   "author": {
     "name": "Philipp Melab"

package/dist/chunks/{review-CNgN_V8T.mjs → review-CXzUXJHL.mjs}

@@ -387,13 +387,14 @@ const requirePointers = (review, notes, codeChanged) => {
 * pointing at its code and each of the lap's notes a chunk of its own; gtd
 * then adds each note's text and answer boxes, and the summary chunks.
 */
-const walkthrough = async (base, report, lap, carry) => {
+const walkthrough = async (base, report, lap, carry, afterRiskFix) => {
 	const notes = titledNotes(report);
 	await reviewing(base, carry, lap, walkthroughBlock(notes, report.nitFix));
 	const written = read(REVIEW);
 	if (written === void 0) return;
 	const review = unranked(written);
 	requirePointers(written, notes, changesSince(base).some((c) => isCode(c.path)));
+	if (!afterRiskFix && reviewRisks(written).length > 0) return;
 	const full = sectionedReview(await ranked(review, withWalkthrough(review, report), new Set(notes.map((n) => n.title))), new Set(reviewChunks(review).map((c) => c.title)));
 	if (full !== written) await run("review.carrying", writeScript(REVIEW, full), {
 		label: "Ordering the review and adding the quality lap's findings",
@@ -419,16 +420,22 @@ const humanReview = (base, escalations = { rounds: 0 }, options = {}) => {
 	const severities = /* @__PURE__ */ new Map();
 	let nitFix;
 	const answered = /* @__PURE__ */ new Set();
+	let riskFixed = false;
 	return review(base, {
 		file: REVIEW,
 		feedback: feedback.file,
 		isCode,
 		reviewing: (b, carry) => {
 			const fixedAt = nitFix;
+			const afterRiskFix = riskFixed;
+			riskFixed = false;
 			const report = options.report ?? NO_FINDINGS;
-			return options.walkthrough === true ? guarded(() => walkthrough(b, composedOf(b, report, fixedAt, answered), options.lap ?? "first", carry), guard)() : composing(b, report, carry, fixedAt, answered);
+			return options.walkthrough === true ? guarded(() => walkthrough(b, composedOf(b, report, fixedAt, answered), options.lap ?? "first", carry, afterRiskFix), guard)() : composing(b, report, carry, fixedAt, answered);
 		},
-		fixRisks: guarded((notes) => fixRisks(notes, fixAccess, rules), guard),
+		fixRisks: guarded((notes) => {
+			riskFixed = true;
+			return fixRisks(notes, fixAccess, rules);
+		}, guard),
 		keepGreen: () => healthy(() => fixCheck(rules), {
 			escalations,
 			guard,

package/dist/workflows/feature.mjs

@@ -2,7 +2,7 @@ import { agent, answered, applyScript, changes, changesSince, check, codeChanges
 import { lensEntriesOf } from "../workflow-kit.mjs";
 import { $ as observableMessage, B as designGateAnswerMessage, Ct as testerSystem, D as planner, Dt as unwindFailure, Et as unwindFailedMessage, H as designSystem, I as clearCriteriaMessage, J as implementBuildingPrompt, L as clearCriteriaQuestion, M as buildReviewCollectingPrompt, Mt as envDefaults, Nt as testFileGlobs, P as builderSystem, Q as normaliseCriteriaScript, S as collecting, St as startGateBlockedMessage, U as designTriagePrompt, V as designImpactPrompt, X as naiveApplyFailure, Y as implementFixPrompt, Z as naivePassPrompt, _ as REQUIREMENTS, a as flagModeOn, bt as seamByHandMessage, ct as refactorBuildingPrompt, d as healthy, dt as refactorNotePrompt, et as observableQuestion, f as FEEDBACK, ft as refactorRules, g as REFACTOR_NOTE, h as REFACTOR, i as skills, it as prototypeUnguidedMessage, j as agentWithSkills, jt as defaults, l as gate, lt as refactorDroppedRefusal, n as summary, nt as prototypeOpenMessage, p as PROTOTYPE, q as idleMessage, r as access, rt as prototypeTestingPrompt, s as shipped, t as steering, tt as prototypeFixingPrompt, ut as refactorFixPrompt, w as fixNits, x as coder, xt as seamSteerMessage, y as answerReviewQuestions, yt as reviewerSystem, z as criterionLine } from "../chunks/reserved-CQ7amcKG.mjs";
 import { a as refusePendingHandOff, o as tail } from "../chunks/tail-JZ9PAOwp.mjs";
-import { i as reUnwind, n as humanReview, r as isCode$1, t as buildTail } from "../chunks/review-CNgN_V8T.mjs";
+import { i as reUnwind, n as humanReview, r as isCode$1, t as buildTail } from "../chunks/review-CXzUXJHL.mjs";
 import { posix } from "node:path";
 //#region src/workflows/shared/fences.ts
 const markFenced = (text) => {

package/dist/workflows/review.mjs

@@ -1,7 +1,7 @@
 import { read, refuse, removeScript, run, start } from "../flows.mjs";
 import { Mt as envDefaults, W as finisherSystem, _ as REQUIREMENTS, gt as reviewGateBlockedMessage, ht as reviewFeedbackFixPrompt, i as skills, j as agentWithSkills, jt as defaults, l as gate, n as summary, r as access, s as shipped, t as steering, x as coder } from "../chunks/reserved-CQ7amcKG.mjs";
 import { a as refusePendingHandOff } from "../chunks/tail-JZ9PAOwp.mjs";
-import { i as reUnwind, t as buildTail } from "../chunks/review-CNgN_V8T.mjs";
+import { i as reUnwind, t as buildTail } from "../chunks/review-CXzUXJHL.mjs";
 //#region src/workflows/review/review.ts
 const fixFeedback = async () => {
 	await agentWithSkills("feedback.fixing", reviewFeedbackFixPrompt(), {

package/dist/workflows.mjs

@@ -39584,13 +39584,14 @@ const requirePointers = (review, notes, codeChanged) => {
 * pointing at its code and each of the lap's notes a chunk of its own; gtd
 * then adds each note's text and answer boxes, and the summary chunks.
 */
-const walkthrough = async (base, report, lap, carry) => {
+const walkthrough = async (base, report, lap, carry, afterRiskFix) => {
 	const notes = titledNotes(report);
 	await reviewing(base, carry, lap, walkthroughBlock(notes, report.nitFix));
 	const written = read(REVIEW);
 	if (written === void 0) return;
 	const review = unranked(written);
 	requirePointers(written, notes, changesSince(base).some((c) => isCode$1(c.path)));
+	if (!afterRiskFix && reviewRisks(written).length > 0) return;
 	const full = sectionedReview(await ranked(review, withWalkthrough(review, report), new Set(notes.map((n) => n.title))), new Set(reviewChunks(review).map((c) => c.title)));
 	if (full !== written) await run("review.carrying", writeScript(REVIEW, full), {
 		label: "Ordering the review and adding the quality lap's findings",
@@ -39616,16 +39617,22 @@ const humanReview = (base, escalations = { rounds: 0 }, options = {}) => {
 	const severities = /* @__PURE__ */ new Map();
 	let nitFix;
 	const answered = /* @__PURE__ */ new Set();
+	let riskFixed = false;
 	return review$1(base, {
 		file: REVIEW,
 		feedback: feedback.file,
 		isCode: isCode$1,
 		reviewing: (b, carry) => {
 			const fixedAt = nitFix;
+			const afterRiskFix = riskFixed;
+			riskFixed = false;
 			const report = options.report ?? NO_FINDINGS;
-			return options.walkthrough === true ? guarded(() => walkthrough(b, composedOf(b, report, fixedAt, answered), options.lap ?? "first", carry), guard)() : composing(b, report, carry, fixedAt, answered);
+			return options.walkthrough === true ? guarded(() => walkthrough(b, composedOf(b, report, fixedAt, answered), options.lap ?? "first", carry, afterRiskFix), guard)() : composing(b, report, carry, fixedAt, answered);
 		},
-		fixRisks: guarded((notes) => fixRisks(notes, fixAccess, rules), guard),
+		fixRisks: guarded((notes) => {
+			riskFixed = true;
+			return fixRisks(notes, fixAccess, rules);
+		}, guard),
 		keepGreen: () => healthy(() => fixCheck(rules), {
 			escalations,
 			guard,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "53.0.0",
+  "version": "54.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/testkit/steps.ts

@@ -193,6 +193,21 @@ Given(
   },
 )
 
+// An agent's edit in place, keeping whatever gtd wrote around it.
+Given(
+  "step {string} replaces the text {string} in {string} with {string}",
+  (world: TestkitWorld, step: string, text: string, path: string, replacement: string) => {
+    world.act(step, (_, repo) => {
+      const content = repo.read(path) ?? ""
+      assert.ok(content.includes(text), `${path}: ${content}`)
+      repo.write(
+        path,
+        content.replace(text, () => replacement),
+      )
+    })
+  },
+)
+
 Given("step {string} deletes {string}", (world: TestkitWorld, step: string, path: string) => {
   world.act(step, (_, repo) => repo.remove(path))
 })
@@ -390,6 +405,14 @@ Then(
   },
 )
 
+Then(
+  "{string} contains {string} exactly once",
+  (world: TestkitWorld, path: string, text: string) => {
+    const content = world.repo().read(path) ?? ""
+    assert.strictEqual(content.split(text).length - 1, 1, `${path}: ${content}`)
+  },
+)
+
 Then("{string} does not contain {string}", (world: TestkitWorld, path: string, text: string) => {
   const content = world.repo().read(path)
   assert.ok(content !== undefined && !content.includes(text), `${path}: ${content}`)

package/src/workflows/feature/lens-review.feature

@@ -161,6 +161,56 @@ Feature: the quality lap's findings are triaged before the review
       gtd(check): build.review.carrying → build.review.await-review
       """
 
+  Scenario: a risk is fixed before the human sees the review, re-reviewed in the reviewer's own draft
+    Given judge step "build.quality.triage" answers:
+      """
+      [{"id":"Q1","answer":"mechanical","p":0.9},{"id":"Q2","answer":"noise","p":0.85},{"id":"Q3","answer":"design","p":0.8}]
+      """
+    And step "build.fix.quality.fixing" writes "src/calc.test.ts" with:
+      """
+      it("[AC-1] subtracts", () => {})
+      it("subtracts a larger number", () => {})
+      """
+    And step "build.fix.quality.fixing" deletes ".gtd/QUALITY.md"
+    And step "build.health.check" changes nothing
+    And step "build.review.reviewing" writes ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## Subtract
+
+      - [ ] ./src/calc.ts#2-2 — Risk: overflows on large numbers
+
+      ## AC-1 ignores floating point
+
+      - [ ] ./src/calc.ts#2-2 — where it applies
+      """
+    When the process is driven
+    Then the process rests at "build.review.fix.risks.fixing"
+    Given step "build.review.reviewing" is no longer scripted
+    And step "build.review.reviewing" replaces the text "Risk: overflows on large numbers" in ".gtd/REVIEW.md" with "subtract(a, b), now guarded"
+    And step "build.review.fix.risks.fixing" changes nothing
+    When the process is driven
+    Then the process rests at "build.review.await-review"
+    And ".gtd/REVIEW.md" contains "subtract(a, b), now guarded"
+    And ".gtd/REVIEW.md" contains "## Fixed automatically" exactly once
+    And ".gtd/REVIEW.md" contains "## Dropped as noise" exactly once
+    And ".gtd/REVIEW.md" contains "## Walkthrough" exactly once
+    And ".gtd/REVIEW.md" contains "Should subtract round? The criterion does not say." exactly once
+    And ".gtd/REVIEW.md" contains "Tick exactly one:" exactly once
+    And the commit subjects end with:
+      """
+      gtd(check): build.health.check → build.review.reviewing
+      gtd(agent): build.review.reviewing → build.review.fix.risks.fixing
+      gtd(agent): build.review.fix.risks.fixing → build.health.check
+      gtd(check): build.health.check → build.review.reviewing
+      gtd(agent): build.review.reviewing → build.review.ranking
+      gtd(judge): build.review.ranking → build.review.carrying
+      gtd(check): build.review.carrying → build.review.await-review
+      """
+
   Scenario: an unsure verdict makes a finding a note, never a fix or a drop
     Given judge step "build.quality.triage" answers:
       """

package/src/workflows/feature/refactor-review.feature

@@ -1185,6 +1185,44 @@ Feature: the refactor is reviewed on its own before the feature is implemented
         """
       And no commit body contains "refactor.build.review.composing"
 
+    Scenario: a risk the refactor's re-review marks again reaches the human unfixed
+      Given step "refactor.build.review.reviewing" writes ".gtd/REVIEW.md" with:
+        """
+        # Review: abc1234
+
+        <!-- base: 0000000 -->
+
+        ## calc
+
+        - [ ] ./src/calc.ts#1-2 — Risk: drops the sign
+        """
+      When the process is driven
+      Then the process rests at "refactor.build.review.fix.risks.fixing"
+      Given step "refactor.build.review.reviewing" is no longer scripted
+      And step "refactor.build.review.reviewing" replaces the text "Risk: drops the sign" in ".gtd/REVIEW.md" with "Risk: still drops the sign"
+      And step "refactor.build.review.fix.risks.fixing" changes nothing
+      And step "refactor.build.health.check" changes nothing
+      When the process is driven
+      Then the process rests at "refactor.build.review.await-review"
+      And ".gtd/REVIEW.md" contains:
+        """
+        ## Walkthrough
+
+        ### calc
+
+        - [ ] ./src/calc.ts#1-2 — Risk: still drops the sign
+        """
+      And ".gtd/REVIEW.md" contains "## Walkthrough" exactly once
+      And the commit subjects end with:
+        """
+        gtd(agent): refactor.build.review.reviewing → refactor.build.review.fix.risks.fixing
+        gtd(agent): refactor.build.review.fix.risks.fixing → refactor.build.health.check
+        gtd(check): refactor.build.health.check → refactor.build.review.reviewing
+        gtd(agent): refactor.build.review.reviewing → refactor.build.review.ranking
+        gtd(judge): refactor.build.review.ranking → refactor.build.review.carrying
+        gtd(check): refactor.build.review.carrying → refactor.build.review.await-review
+        """
+
   Rule: with a quality lens on both the refactor and the feature
 
     Background:

package/src/workflows/feature/reviewer-walkthrough.feature

@@ -179,37 +179,6 @@ Feature: a reviewer walks the human through the feature's code
       """
     Then driving the process is refused with "AC-1 ignores floating point — no chunk of its own"
 
-  Scenario: a risk the reviewer marks is fixed before the human sees the review
-    Given step "build.review.reviewing" writes ".gtd/REVIEW.md" with:
-      """
-      # Review: abc1234
-
-      <!-- base: 0000000 -->
-
-      ## Subtract
-
-      - [ ] ./src/calc.ts#2-2 — Risk: overflows on large numbers
-
-      ## AC-1 ignores floating point
-
-      - [ ] ./src/calc.ts#2-2 — returns the raw difference
-      """
-    And step "build.review.fix.risks.fixing" changes nothing
-    And step "build.health.check" changes nothing
-    When the process is driven
-    Then the process rests at "build.review.await-review"
-    And the commit subjects end with:
-      """
-      gtd(agent): build.review.reviewing → build.review.ranking
-      gtd(judge): build.review.ranking → build.review.carrying
-      gtd(check): build.review.carrying → build.review.fix.risks.fixing
-      gtd(agent): build.review.fix.risks.fixing → build.health.check
-      gtd(check): build.health.check → build.review.reviewing
-      gtd(agent): build.review.reviewing → build.review.ranking
-      gtd(judge): build.review.ranking → build.review.carrying
-      gtd(check): build.review.carrying → build.review.await-review
-      """
-
   Scenario: a standard conflict the reviewer writes itself is refused
     Given step "build.review.reviewing" writes ".gtd/REVIEW.md" with:
       """

package/src/workflows/shared/review.ts

@@ -380,6 +380,7 @@ const walkthrough = async (
   report: t.ComposedReview,
   lap: t.ReviewRange,
   carry: string | undefined,
+  afterRiskFix: boolean,
 ): Promise<void> => {
   const notes = t.titledNotes(report)
   await reviewing(base, carry, lap, t.walkthroughBlock(notes, report.nitFix))
@@ -393,7 +394,8 @@ const walkthrough = async (
     notes,
     changesSince(base).some((c) => isCode(c.path)),
   )
-  // Ranked even when it marks risks: the review written after their fix reaches the human with its own.
+  // Its risks are fixed and the review written again, so the re-reviewer edits this draft, never gtd's layout.
+  if (!afterRiskFix && reviewRisks(written).length > 0) return
   const full = sectionedReview(
     await ranked(review, t.withWalkthrough(review, report), new Set(notes.map((n) => n.title))),
     new Set(reviewChunks(review).map((c) => c.title)),
@@ -432,12 +434,16 @@ export const humanReview = (
   let nitFix: string | undefined
   // Every note the human answered in this review, left out of a fresh one.
   const answered = new Set<string>()
+  // Set by a risk fix, so the review written next reaches the human whatever it marks.
+  let riskFixed = false
   return kit.review(base, {
     file: REVIEW,
     feedback: feedback.file,
     isCode,
     reviewing: (b, carry) => {
       const fixedAt = nitFix
+      const afterRiskFix = riskFixed
+      riskFixed = false
       const report = options.report ?? NO_FINDINGS
       return options.walkthrough === true
         ? guarded(
@@ -447,12 +453,16 @@ export const humanReview = (
                 composedOf(b, report, fixedAt, answered),
                 options.lap ?? "first",
                 carry,
+                afterRiskFix,
               ),
             guard,
           )()
         : composing(b, report, carry, fixedAt, answered)
     },
-    fixRisks: guarded((notes) => fixRisks(notes, fixAccess, rules), guard),
+    fixRisks: guarded((notes) => {
+      riskFixed = true
+      return fixRisks(notes, fixAccess, rules)
+    }, guard),
     keepGreen: () => healthy(() => fixCheck(rules), { escalations, guard, guardRests, rules }),
     // Kept until the human sees a review, so a re-review after a risk fix still names it.
     awaitReview: (b) => {