@pmelab/gtd 33.0.0 → 34.0.0

package/.claude-plugin/plugin.json

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

@@ -405,9 +405,10 @@ phone UI does not show them).
 
 ### The workflow it ships with
 
-One built-in workflow drives all of that. From where you sit, it has four
+One built-in workflow drives all of that. From where you sit, it has three
 moments — everything between them runs without you, with the judged exceptions
-noted in steps 3 and 4 below.
+noted in step 3 below — plus a fourth, review, only on `refactor-first` or when
+you open the `review` door.
 
 1. **You sketch.** Change anything, or write the idea into `.gtd/TODO.md`. Rough
    is fine; it is treated as a sketch, not as work.
@@ -431,13 +432,15 @@ noted in steps 3 and 4 below.
    [the naive pass](#the-naive-pass) below; with [flag mode](#the-naive-pass)
    off, neither runs). Then the change is built test-first, checked against the
    full suite (`testCommand`) and fixed until it passes — so keep that suite
-   fast; gtd has no lighter one. Scenario wording is not frozen: you sign the
-   scenarios off once, in the review's `## Scenarios` chunk, where any assertion
-   an existing scenario lost is marked `Weakened:`. After the build the quality
-   lap runs. Three points along the process (two with flag mode off) are judged
-   rather than always asking you outright — each stops and hands you a verdict
-   to make (`gtd judge answer`, or land with a clean tree to accept the
-   conservative default, which never skips work;
+   fast; gtd has no lighter one. Scenario wording is not frozen: a review's
+   `## Scenarios` chunk marks any assertion an existing scenario lost as
+   `Weakened:` — **risk: `feature` has no review, so a build turn that weakens a
+   scenario reaches `idle` unflagged unless you open the `review` door.** After
+   the build the quality lap runs, and the process ends: the feature workflow
+   has no human review of the finished change. Two points along the process (one
+   with flag mode off) are judged rather than always asking you outright — each
+   stops and hands you a verdict to make (`gtd judge answer`, or land with a
+   clean tree to accept the conservative default, which never skips work;
    `gtd judge run --provider fixed --answers <path>` — or the
    `GTD_JUDGE_ANSWERS` env var, inline JSON — answers one from a file, piped
    between `gtd judge --json` and `gtd judge answer`;
@@ -456,8 +459,6 @@ noted in steps 3 and 4 below.
      or get rejected and retried?
    - Every red round after the first: was the failure identical, new, or
      progress?
-   - After you review: is each of your notes an edit, a question, a nit or
-     praise?
 
    gtd itself never calls a judge: `gtd loop`, the Claude Code mod and the
    reference driver answer these through `gtd judge run` (auto selection: jev
@@ -469,18 +470,22 @@ noted in steps 3 and 4 below.
    and skip a gate unattended.**
 
    Once the change is built, the whole change goes through a qualitative review
-   lap before you see anything: six lenses, one turn each, in order —
-   `correctness`, `owasp-security`, `ponytail-review`, `test-audit`,
-   `conventions`, `spec-challenge`. `correctness`, `owasp-security` and
-   `spec-challenge` run on the planner model (`smart`), the other three on the
-   coder model (`base`); a `qualityReviews` entry `<lens>=<model>` picks a
-   lens's own. Each traces the change from its own angle and records every
-   finding, blocking or not; one fix turn then fixes ALL of them once, with no
-   re-review after the fix. A clean turn means approval only when that lens
-   found nothing at all. This lap is where code quality is looked at, and every
-   round pays for it. It never replaces step 4 — your review stays the final
-   gate, and nothing here skips it. The `fix` door (below) repairs a red
-   baseline through this same lap.
+   lap: six lenses, one turn each, in order — `correctness`, `owasp-security`,
+   `ponytail-review`, `test-audit`, `conventions`, `spec-challenge`.
+   `correctness`, `owasp-security` and `spec-challenge` run on the planner model
+   (`smart`), the other three on the coder model (`base`); a `qualityReviews`
+   entry `<lens>=<model>` picks a lens's own. Each traces the change from its
+   own angle and records every finding, blocking or not; one fix turn then fixes
+   ALL of them once, with no re-review after the fix. A clean turn means
+   approval only when that lens found nothing at all. This lap is where code
+   quality is looked at, and every round pays for it. It is the last look the
+   feature workflow takes: the process ends at `idle` once it is clean (and the
+   suite green), with no review rest — **risk: nothing re-reads the code the
+   single fix turn writes; only the suite gates it.** Findings the fix cap
+   leaves in `.gtd/QUALITY.md` rest at `build.quality-unresolved` until you
+   delete or empty the file; the suite then runs on any hand edits. **Nobody
+   signs the finished change off unless you open the `review` door** (below).
+   The `fix` door repairs a red baseline through this same lap.
 
    A red suite that keeps failing past a few fix attempts escalates instead of
    retrying forever: an agent turn reads the failing output and writes
@@ -491,22 +496,28 @@ noted in steps 3 and 4 below.
    instead of a third being written, and editing it is what gets the next
    attempt anywhere new.
 
-4. **You review.** You get a review document listing what changed and what to
-   look at. Before you see it, an automatic risk-fix pass
-   (`build.review.fix.risks.fixing`) runs. Any risk the reviewer names (a note
-   opening with `Risk:`) is fixed first, the suite kept green, and the review
-   rewritten — once per review round, so a risk the rewrite still names reaches
-   you unfixed; risk: a fix lands with no check that the risk was real. Tick the
-   boxes to approve, or write what is wrong. Approving ends the process;
-   feedback is judged note by note, each as `edit`, `question`, `nit` or
-   `praise`. An `edit` sends the process back to step 2 for re-derived
-   requirements, and the implementation is amended to meet them. A `question` is
-   answered inline under your note and the process stops at the review again —
-   no new plan. A `nit` is fixed in one batch, the suite must go green (a red
-   one gets fix turns first), then a fresh review of the change stops at the
-   review again. `praise` is dropped; a round of only praise signs off. When a
-   round mixes them, questions are answered and nits fixed first, then the edits
-   are planned — risk: the planning lap may redo nit fixes it touches.
+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
+   feature is built (see [the naive pass](#the-naive-pass)). For the finished
+   change run `gtd door review <commitish>` (`/gtd review [base]`); that review
+   hands notes to `fix` instead of re-planning (below). Either way you get a
+   review document listing what changed and what to look at. Before you see it,
+   an automatic risk-fix pass (`build.review.fix.risks.fixing`) runs. Any risk
+   the reviewer names (a note opening with `Risk:`) is fixed first, the suite
+   kept green, and the review rewritten — once per review round, so a risk the
+   rewrite still names reaches you unfixed; risk: a fix lands with no check that
+   the risk was real. Tick the boxes to approve, or write what is wrong. At the
+   refactor review, approving moves on to the feature; feedback is judged note
+   by note (a third judged point), each as `edit`, `question`, `nit` or
+   `praise`. An `edit` re-derives the refactor (in a custom workflow built on
+   `buildTail`, it sends the process back to step 2 for re-derived
+   requirements). A `question` is answered inline under your note and the
+   process stops at the review again — no new plan. A `nit` is fixed in one
+   batch, the suite must go green (a red one gets fix turns first), then a fresh
+   review of the change stops at the review again. `praise` is dropped; a round
+   of only praise signs off. When a round mixes them, questions are answered and
+   nits fixed first, then the edits are planned — risk: the planning lap may
+   redo nit fixes it touches.
 
    Each `edit` note also gets a severity tier from four judge questions
    (security, reversibility, blast radius, new concept). `critical` and `should`
@@ -526,7 +537,7 @@ noted in steps 3 and 4 below.
 You never talk to it. Every exchange is a file in `.gtd/` that you edit in your
 own editor, and every answer you give is a commit. Your test suite is the gate
 throughout: a red baseline stops the process before it starts, and a red build
-is fixed before review.
+is fixed before the process ends.
 
 Prefer a phone or another device over your editor? `gtd ui` opens the file whose
 turn it is as a small web app, over Tailscale — including a step that names no
@@ -596,16 +607,15 @@ file it added, or the suite is red on it. A judge checks whether it changed
 anything outside the expected set (tests, steering files; see `seamAllow`).
 Incidental changes land; a needed seam change is refactored first, in its own
 slice with its own quality lap (`refactorQualityReviews`) and review, before the
-feature is implemented and reviewed; a wrong approach is retried twice, then
-rests for you to steer or overrule it. `gtd slices` lists the `refactor` and
-`feature` slices. A refactor that already carried the whole feature leaves the
-implementation nothing to do: its empty turn passes, and the feature review
-covers the whole change. Feedback at the feature review re-runs design and the
-implementation, never the naive pass; feedback at the refactor review re-runs
-the refactor, never design; a refactor-review change the refactor cannot build
-is refused, and the only way out is `gtd abandon`. A process from 27.5.0 or
-later whose judge ruled `refactor-first` must `gtd abandon` too. Each slice's
-quality lap reviews only that slice. Details in
+feature is implemented; a wrong approach is retried twice, then rests for you to
+steer or overrule it. `gtd slices` lists the `refactor` and `feature` slices. A
+refactor that already carried the whole feature leaves the implementation
+nothing to do: its empty turn passes, and the feature's quality lap covers the
+whole change. Feedback at the refactor review re-runs the refactor, never
+design; a refactor-review change the refactor cannot build is refused, and the
+only way out is `gtd abandon`. A process from 27.5.0 or later whose judge ruled
+`refactor-first` must `gtd abandon` too. Each slice's quality lap reviews only
+that slice. Details in
 [the naive-pass path](docs/configuration.md#the-naive-pass-path).
 
 **Flag mode (`flagMode`, on by default).** On, the implementation is asked for a

package/dist/chunks/{reserved-BU5Zi-nX.mjs → reserved-BcJgt5_R.mjs}

@@ -416,6 +416,17 @@ carries it.
 What each change does next (then run \`gtd land\`):
 - **Continue** — having undone the sketch by hand, check the test baseline is green and start triage (**start-gate.check**).
 `;
+const qualityUnresolvedMessage = () => `The quality lap's fix turns hit their cap and \`.gtd/QUALITY.md\` still
+holds findings. Nothing reviews the change after this, so the process
+will not end with them open.
+
+Fix what matters by hand, then delete or empty \`.gtd/QUALITY.md\` —
+dropping a finding is your call to make.
+
+What each change does next (then run \`gtd land\`):
+- **Delete or empty \`.gtd/QUALITY.md\`** — the suite runs on your edits, then the process ends (**idle**).
+- **Anything else** — rests here again.
+`;
 const startGateBlockedMessage = () => `The test baseline is red — gtd will not start new work on a broken suite.
 \`.gtd/FEEDBACK.md\` holds the failing output.
 
@@ -1629,4 +1640,4 @@ const steering = {
 	[REVIEW]: "review"
 };
 //#endregion
-export { reviewEditNotesCapture as $, buildReviewCollectingPrompt as A, designTriagePrompt as B, planner as C, agentWithSkills as D, reviewing as E, clearCriteriaQuestion as F, implementBuildingPrompt as G, fixReviewNotesPrompt as H, criterionLine as I, normaliseCriteriaScript as J, implementFixPrompt as K, deferNotesScript as L, buildReviewTriageMessage as M, builderSystem as N, buildReviewAnswerQuestionsPrompt as O, clearCriteriaMessage as P, refactorRules as Q, designGateAnswerMessage as R, fixRisks as S, reviewQuality as T, handOffAwaitReviewMessage as U, finisherSystem as V, idleMessage as W, refactorDroppedRefusal as X, refactorBuildingPrompt as Y, refactorFixPrompt as Z, REVIEW as _, flagModeOn as a, seamSteerMessage as at, fixCheck as b, baseline as c, unwindFailure as ct, guarded as d, testFileGlobs as dt, reviewEditsCapture as et, healthy as f, flagMentions as ft, REQUIREMENTS as g, requireFlag as gt, REFACTOR as h, registryEntry as ht, skills as i, seamByHandMessage as it, buildReviewFixNitsPrompt as j, buildReviewAwaitAfterDeferMessage as k, escalation as l, defaults as lt, QUALITY as m, flipProblems as mt, summary as n, reviewNotesCapture as nt, flagShipped as o, startGateBlockedMessage as ot, FEEDBACK as p, flagReferences as pt, naivePassPrompt as q, access as r, reviewerSystem as rt, shipped as s, unwindFailedMessage as st, steering as t, reviewGateBlockedMessage as tt, gate as u, envDefaults as ut, awaitReview as v, reviewMissing as w, fixQuality as x, coder as y, designSystem as z };
+export { refactorRules as $, buildReviewCollectingPrompt as A, designTriagePrompt as B, planner as C, agentWithSkills as D, reviewing as E, clearCriteriaQuestion as F, implementBuildingPrompt as G, fixReviewNotesPrompt as H, criterionLine as I, normaliseCriteriaScript as J, implementFixPrompt as K, deferNotesScript as L, buildReviewTriageMessage as M, builderSystem as N, buildReviewAnswerQuestionsPrompt as O, clearCriteriaMessage as P, refactorFixPrompt as Q, designGateAnswerMessage as R, fixRisks as S, reviewQuality as T, handOffAwaitReviewMessage as U, finisherSystem as V, idleMessage as W, refactorBuildingPrompt as X, qualityUnresolvedMessage as Y, refactorDroppedRefusal as Z, REVIEW as _, requireFlag as _t, flagModeOn as a, seamByHandMessage as at, fixCheck as b, baseline as c, unwindFailedMessage as ct, guarded as d, envDefaults as dt, reviewEditNotesCapture as et, healthy as f, testFileGlobs as ft, REQUIREMENTS as g, registryEntry as gt, REFACTOR as h, flipProblems as ht, skills as i, reviewerSystem as it, buildReviewFixNitsPrompt as j, buildReviewAwaitAfterDeferMessage as k, escalation as l, unwindFailure as lt, QUALITY as m, flagReferences as mt, summary as n, reviewGateBlockedMessage as nt, flagShipped as o, seamSteerMessage as ot, FEEDBACK as p, flagMentions as pt, naivePassPrompt as q, access as r, reviewNotesCapture as rt, shipped as s, startGateBlockedMessage as st, steering as t, reviewEditsCapture as tt, gate as u, defaults as ut, awaitReview as v, reviewMissing as w, fixQuality as x, coder as y, designSystem as z };

package/dist/chunks/{tail-DuXanjIY.mjs → tail-CM_fa93v.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 { E as reviewing, S as fixRisks, T as reviewQuality, U as handOffAwaitReviewMessage, _ as REVIEW, b as fixCheck, d as guarded, f as healthy, l as escalation, m as QUALITY, v as awaitReview, w as reviewMissing, x as fixQuality } from "./reserved-BU5Zi-nX.mjs";
+import { E as reviewing, S as fixRisks, T as reviewQuality, U as handOffAwaitReviewMessage, _ as REVIEW, b as fixCheck, d as guarded, f as healthy, l as escalation, m as QUALITY, v as awaitReview, w as reviewMissing, x as fixQuality } from "./reserved-BcJgt5_R.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/workflows/cleanup.mjs

@@ -1,6 +1,6 @@
 import { agent, changes, glob, read, refuse, scope, start, vars } from "../flows.mjs";
-import { gt as requireFlag, ht as registryEntry, i as skills, lt as defaults, n as summary, o as flagShipped, pt as flagReferences, r as access, t as steering, ut as envDefaults, y as coder } from "../chunks/reserved-BU5Zi-nX.mjs";
-import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-DuXanjIY.mjs";
+import { _t as requireFlag, dt as envDefaults, gt as registryEntry, i as skills, mt as flagReferences, n as summary, o as flagShipped, r as access, t as steering, ut as defaults, y as coder } from "../chunks/reserved-BcJgt5_R.mjs";
+import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-CM_fa93v.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 { answered, changes, changesSince, check, 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 } from "../flows.mjs";
 import { lensEntriesOf, review as review$1 } from "../workflow-kit.mjs";
-import { $ as reviewEditNotesCapture, A as buildReviewCollectingPrompt, B as designTriagePrompt, C as planner, D as agentWithSkills, E as reviewing, F as clearCriteriaQuestion, G as implementBuildingPrompt, I as criterionLine, J as normaliseCriteriaScript, K as implementFixPrompt, L as deferNotesScript, M as buildReviewTriageMessage, N as builderSystem, O as buildReviewAnswerQuestionsPrompt, P as clearCriteriaMessage, Q as refactorRules, R as designGateAnswerMessage, S as fixRisks, W as idleMessage, X as refactorDroppedRefusal, Y as refactorBuildingPrompt, Z as refactorFixPrompt, _ as REVIEW, a as flagModeOn, at as seamSteerMessage, b as fixCheck, ct as unwindFailure, d as guarded, dt as testFileGlobs, et as reviewEditsCapture, f as healthy, g as REQUIREMENTS, h as REFACTOR, i as skills, it as seamByHandMessage, j as buildReviewFixNitsPrompt, k as buildReviewAwaitAfterDeferMessage, lt as defaults, n as summary, nt as reviewNotesCapture, ot as startGateBlockedMessage, p as FEEDBACK, q as naivePassPrompt, r as access, rt as reviewerSystem, s as shipped, st as unwindFailedMessage, t as steering, u as gate, ut as envDefaults, v as awaitReview, w as reviewMissing, y as coder, z as designSystem } from "../chunks/reserved-BU5Zi-nX.mjs";
-import { a as refusePendingHandOff, i as isOptionalObject, n as closeReview, o as tail } from "../chunks/tail-DuXanjIY.mjs";
+import { $ as refactorRules, A as buildReviewCollectingPrompt, B as designTriagePrompt, C as planner, D as agentWithSkills, E as reviewing, F as clearCriteriaQuestion, G as implementBuildingPrompt, I as criterionLine, J as normaliseCriteriaScript, K as implementFixPrompt, L as deferNotesScript, M as buildReviewTriageMessage, N as builderSystem, O as buildReviewAnswerQuestionsPrompt, P as clearCriteriaMessage, Q as refactorFixPrompt, R as designGateAnswerMessage, S as fixRisks, W as idleMessage, X as refactorBuildingPrompt, Y as qualityUnresolvedMessage, Z as refactorDroppedRefusal, _ as REVIEW, a as flagModeOn, at as seamByHandMessage, b as fixCheck, ct as unwindFailedMessage, d as guarded, dt as envDefaults, et as reviewEditNotesCapture, f as healthy, ft as testFileGlobs, g as REQUIREMENTS, h as REFACTOR, i as skills, it as reviewerSystem, j as buildReviewFixNitsPrompt, k as buildReviewAwaitAfterDeferMessage, lt as unwindFailure, m as QUALITY, n as summary, ot as seamSteerMessage, p as FEEDBACK, q as naivePassPrompt, r as access, rt as reviewNotesCapture, s as shipped, st as startGateBlockedMessage, t as steering, tt as reviewEditsCapture, u as gate, ut as defaults, v as awaitReview, w as reviewMissing, y as coder, z as designSystem } from "../chunks/reserved-BcJgt5_R.mjs";
+import { a as refusePendingHandOff, i as isOptionalObject, n as closeReview, o as tail } from "../chunks/tail-CM_fa93v.mjs";
 import { posix } from "node:path";
 //#region src/workflows/shared/fences.ts
 const markFenced = (text) => {
@@ -958,7 +958,7 @@ const unwind = () => {
 	const commit = head();
 	return run("unwind", revertScript(commit, FEEDBACK, unwindFailure(commit)), { label: "Unwinding your input" });
 };
-/** A judged naive pass (none with `flagMode` off), then implement and review until a review round signs off; design must have run since `firstBase`. */
+/** A judged naive pass (none with `flagMode` off), then implement and the quality lap; design must have run since `firstBase`. */
 const buildFeature = async (firstBase) => {
 	const tier = riskTierOn() ? recordRisk() : void 0;
 	const seam = flagModeOn() ? await seamBuild(firstBase) : { base: firstBase };
@@ -969,18 +969,31 @@ const buildFeature = async (firstBase) => {
 			afterRefactor: seam.refactored
 		});
 		const base = seam.refactored === true && !changesSince(seam.base).some((c) => isCode$1(c.path)) ? firstBase : seam.base;
-		await featureFeedback(await buildTail(base, {
+		await tail(settleQuality, {
 			green: true,
 			lensBase: base
-		}), base);
+		});
 	});
 };
+const settleQuality = async () => {
+	let rested = false;
+	while ((read(".gtd/QUALITY.md") ?? "").length > 0) {
+		rested = true;
+		await human("quality-unresolved", {
+			message: qualityUnresolvedMessage(),
+			label: "Quality findings left unresolved",
+			file: QUALITY
+		});
+	}
+	if (rested) await healthy(() => fixCheck());
+};
 /** Design — skipped when the sketch's own criteria are judged clear — then `buildFeature`. */
 const planAndBuild = async (firstBase, stated) => {
 	if (!await skipDesign(riskTierOn() ? void 0 : stated)) await design(firstBase);
 	await buildFeature(firstBase);
 };
-const featureFeedback = async (first, lensBase) => {
+/** After a tail that skipped planning: stop on sign-off, re-plan on feedback. Opens no slice: slices cannot nest. */
+const afterTail = async (first) => {
 	let outcome = first;
 	while (outcome.verdict === "feedback") {
 		await reUnwind(outcome);
@@ -991,13 +1004,10 @@ const featureFeedback = async (first, lensBase) => {
 		});
 		outcome = await buildTail(outcome.base, {
 			green: true,
-			lap: "feedback",
-			lensBase
+			lap: "feedback"
 		});
 	}
 };
-/** After a tail that skipped planning: stop on sign-off, re-plan on feedback. Opens no slice: slices cannot nest. */
-const afterTail = (outcome) => featureFeedback(outcome);
 /** An ordinary start: wait at `idle`, unwind the sketch, check the baseline, then plan and build. */
 const ordinaryStart = async () => {
 	await human("idle", {

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 { D as agentWithSkills, H as fixReviewNotesPrompt, V as finisherSystem, _ as REVIEW, c as baseline, i as skills, lt as defaults, n as summary, r as access, s as shipped, t as steering, ut as envDefaults, y as coder } from "../chunks/reserved-BU5Zi-nX.mjs";
-import { r as handOffTail, t as REVIEW_ORIG } from "../chunks/tail-DuXanjIY.mjs";
+import { D as agentWithSkills, H as fixReviewNotesPrompt, V as finisherSystem, _ as REVIEW, c as baseline, dt as envDefaults, i as skills, n as summary, r as access, s as shipped, t as steering, ut as defaults, y as coder } from "../chunks/reserved-BcJgt5_R.mjs";
+import { r as handOffTail, t as REVIEW_ORIG } from "../chunks/tail-CM_fa93v.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 { i as skills, lt as defaults, n as summary, r as access, s as shipped, t as steering, tt as reviewGateBlockedMessage, u as gate, ut as envDefaults } from "../chunks/reserved-BU5Zi-nX.mjs";
-import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-DuXanjIY.mjs";
+import { dt as envDefaults, i as skills, n as summary, nt as reviewGateBlockedMessage, r as access, s as shipped, t as steering, u as gate, ut as defaults } from "../chunks/reserved-BcJgt5_R.mjs";
+import { a as refusePendingHandOff, r as handOffTail } from "../chunks/tail-CM_fa93v.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 { ft as flagMentions, gt as requireFlag, i as skills, lt as defaults, mt as flipProblems, n as summary, o as flagShipped, p as FEEDBACK, r as access, t as steering, u as gate, ut as envDefaults, y as coder } from "../chunks/reserved-BU5Zi-nX.mjs";
+import { _t as requireFlag, dt as envDefaults, ht as flipProblems, i as skills, n as summary, o as flagShipped, p as FEEDBACK, pt as flagMentions, r as access, t as steering, u as gate, ut as defaults, y as coder } from "../chunks/reserved-BcJgt5_R.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

@@ -17213,6 +17213,17 @@ carries it.
 What each change does next (then run \`gtd land\`):
 - **Continue** — having undone the sketch by hand, check the test baseline is green and start triage (**start-gate.check**).
 `;
+const qualityUnresolvedMessage = () => `The quality lap's fix turns hit their cap and \`.gtd/QUALITY.md\` still
+holds findings. Nothing reviews the change after this, so the process
+will not end with them open.
+
+Fix what matters by hand, then delete or empty \`.gtd/QUALITY.md\` —
+dropping a finding is your call to make.
+
+What each change does next (then run \`gtd land\`):
+- **Delete or empty \`.gtd/QUALITY.md\`** — the suite runs on your edits, then the process ends (**idle**).
+- **Anything else** — rests here again.
+`;
 const startGateBlockedMessage = () => `The test baseline is red — gtd will not start new work on a broken suite.
 \`.gtd/FEEDBACK.md\` holds the failing output.
 
@@ -38760,7 +38771,7 @@ const unwind = () => {
 	const commit = head$1();
 	return run("unwind", revertScript(commit, FEEDBACK, unwindFailure(commit)), { label: "Unwinding your input" });
 };
-/** A judged naive pass (none with `flagMode` off), then implement and review until a review round signs off; design must have run since `firstBase`. */
+/** A judged naive pass (none with `flagMode` off), then implement and the quality lap; design must have run since `firstBase`. */
 const buildFeature = async (firstBase) => {
 	const tier = riskTierOn() ? recordRisk() : void 0;
 	const seam = flagModeOn() ? await seamBuild(firstBase) : { base: firstBase };
@@ -38771,18 +38782,31 @@ const buildFeature = async (firstBase) => {
 			afterRefactor: seam.refactored
 		});
 		const base = seam.refactored === true && !changesSince(seam.base).some((c) => isCode$1(c.path)) ? firstBase : seam.base;
-		await featureFeedback(await buildTail(base, {
+		await tail(settleQuality, {
 			green: true,
 			lensBase: base
-		}), base);
+		});
 	});
 };
+const settleQuality = async () => {
+	let rested = false;
+	while ((read(".gtd/QUALITY.md") ?? "").length > 0) {
+		rested = true;
+		await human("quality-unresolved", {
+			message: qualityUnresolvedMessage(),
+			label: "Quality findings left unresolved",
+			file: QUALITY
+		});
+	}
+	if (rested) await healthy(() => fixCheck());
+};
 /** Design — skipped when the sketch's own criteria are judged clear — then `buildFeature`. */
 const planAndBuild = async (firstBase, stated) => {
 	if (!await skipDesign(riskTierOn() ? void 0 : stated)) await design(firstBase);
 	await buildFeature(firstBase);
 };
-const featureFeedback = async (first, lensBase) => {
+/** After a tail that skipped planning: stop on sign-off, re-plan on feedback. Opens no slice: slices cannot nest. */
+const afterTail = async (first) => {
 	let outcome = first;
 	while (outcome.verdict === "feedback") {
 		await reUnwind(outcome);
@@ -38793,13 +38817,10 @@ const featureFeedback = async (first, lensBase) => {
 		});
 		outcome = await buildTail(outcome.base, {
 			green: true,
-			lap: "feedback",
-			lensBase
+			lap: "feedback"
 		});
 	}
 };
-/** After a tail that skipped planning: stop on sign-off, re-plan on feedback. Opens no slice: slices cannot nest. */
-const afterTail = (outcome) => featureFeedback(outcome);
 /** An ordinary start: wait at `idle`, unwind the sketch, check the baseline, then plan and build. */
 const ordinaryStart = async () => {
 	await human("idle", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "33.0.0",
+  "version": "34.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/skills/authoring/SKILL.md

@@ -224,8 +224,8 @@ workflow.
 
 In the bundled default, `planAndBuild` runs the design phase, then
 `buildFeature`: the naive pass and its seam judge, then the implementation and
-review. Add a human sign-off before the first build (a review feedback lap
-re-runs design inside `buildFeature` and does not pass it again):
+the quality lap, ending with no human review. Add a human sign-off before the
+build:
 
 ```ts
 const planAndBuild = async (firstBase: string): Promise<void> => {

package/src/testkit/steps.ts

@@ -108,6 +108,10 @@ Given("a file {string} with:", (world: TestkitWorld, path: string, content: stri
   world.repo().write(path, withNewline(content))
 })
 
+Given("the file {string} is deleted", (world: TestkitWorld, path: string) => {
+  world.repo().remove(path)
+})
+
 Given("the working tree is committed as {string}", (world: TestkitWorld, message: string) => {
   world.repo().commit(message)
 })

package/src/workflows/feature/fast-path.feature

@@ -2,8 +2,8 @@
 Feature: a trivial change takes the same few beats at either risk tier, flag-free at low
 
   With GTD_FLAG_RISK_TIER on, a one-line copy fix goes
-  from idle through the naive pass, the seam judge's land, implement and human
-  review back to idle. Low tier walks exactly the steps high does; only the
+  from idle through the naive pass, the seam judge's land, implement and the
+  quality lap back to idle. Low tier walks exactly the steps high does; only the
   implementation prompt and the summary differ.
 
   Background:
@@ -27,18 +27,6 @@ Feature: a trivial change takes the same few beats at either risk tier, flag-fre
     And step "implement.health.check" changes nothing
     And step "implement.closing" runs its script
     And step "build.quality.correctness.reviewing" changes nothing
-    And step "build.review.reviewing" writes ".gtd/REVIEW.md" with:
-      """
-      # Review: abc1234
-
-      <!-- base: 0000000 -->
-
-      ## greeting
-
-      - [ ] ./src/greeting.ts#1-1
-        typo fixed
-      """
-    And step "build.review.closing" runs its script
 
   Scenario Outline: a one-line fix runs idle to idle with the same beats at either tier
     Given step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
@@ -80,21 +68,6 @@ Feature: a trivial change takes the same few beats at either risk tier, flag-fre
       export const greeting = "Hello, world!"
       """
     When the process is driven
-    Then the process rests at "build.review.await-review"
-
-    Given a file ".gtd/REVIEW.md" with:
-      """
-      # Review: abc1234
-
-      <!-- base: 0000000 -->
-
-      ## greeting
-
-      - [x] ./src/greeting.ts#1-1
-        typo fixed
-      """
-    When gtd lands
-    And the process is driven
     Then the process rests at "idle"
     And "src/greeting.ts" contains "Hello, world!"
     And the commit subjects end with:
@@ -110,10 +83,7 @@ Feature: a trivial change takes the same few beats at either risk tier, flag-fre
       gtd(agent): implement.building → implement.health.check
       gtd(check): implement.health.check → implement.closing
       gtd(check): implement.closing → build.quality.correctness.reviewing
-      gtd(agent): build.quality.correctness.reviewing → build.review.reviewing
-      gtd(agent): build.review.reviewing → build.review.await-review
-      gtd(human): build.review.await-review → build.review.closing
-      gtd(check): build.review.closing → idle
+      gtd(agent): build.quality.correctness.reviewing → idle
       """
     And the output of gtd "summary" <summary> "needs a human reviewer"
 

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

@@ -64,107 +64,6 @@ const naivePlanned = () => {
   return repo
 }
 
-describe("planAndBuild", () => {
-  it("a refactor that carried the whole feature: the empty implement turn passes and the review covers the whole change", async () => {
-    const repo = naivePlanned()
-    const SUBTRACT = `${CALC}export const subtract = (a: number, b: number) => a - b\n`
-    expect(
-      (
-        await repo.drive({
-          unwind: () => undefined,
-          "start-gate.check": () => undefined,
-          "design.triage": (_, r) =>
-            r.write(
-              ".gtd/REQUIREMENTS.md",
-              "# Requirements\n\n## Concerns\n\n### S\n\n- `s`\n\n## Acceptance Criteria\n\n- AC-1: done\n",
-            ),
-          "design.gate.answer": () => undefined,
-          "seam.naive": (_, r) => {
-            r.write("src/calc.ts", SUBTRACT)
-            r.write("src/calc.test.ts", ACCEPTANCE)
-          },
-          "seam.check": () => undefined,
-          "seam.judge": () => '[{"id":"shape","answer":"refactor-first","p":0.9}]',
-          "refactor.deriving": runsItsScript,
-          "refactor.building": (_, r) => r.write("src/calc.ts", SUBTRACT),
-          "refactor.health.check": () => undefined,
-          "refactor.closing": runsItsScript,
-          "refactor.build.review.reviewing": (_, r) => r.write(".gtd/REVIEW.md", review()),
-        })
-      ).state,
-    ).toBe("refactor.build.review.await-review")
-    await repo.land()
-    const rest = await repo.drive({
-      "refactor.build.review.closing": runsItsScript,
-      "implement.building": () => undefined,
-      "implement.health.check": () => undefined,
-      "implement.closing": runsItsScript,
-      "build.review.reviewing": (_, r) => r.write(".gtd/REVIEW.md", review()),
-    })
-    expect(rest.state).toBe("build.review.await-review")
-    const base = (await repo.gtd("base")).stdout.trim()
-    expect(repo.show(base, "src/calc.ts")).toBe(CALC)
-  })
-
-  it("after land, feedback rests next at design.triage, then implement.building, never seam.naive", async () => {
-    const repo = naivePlanned()
-    const requirements = (_: unknown, r: typeof repo) =>
-      r.write(
-        ".gtd/REQUIREMENTS.md",
-        "# Requirements\n\n## Concerns\n\n### Subtract\n\n- `subtract`\n\n## Acceptance Criteria\n\n- AC-1: done\n",
-      )
-    const lap = {
-      unwind: () => undefined,
-      "start-gate.check": () => undefined,
-      "design.triage": requirements,
-      "design.gate.answer": () => undefined,
-      "seam.naive": (_: unknown, r: typeof repo) => {
-        r.write("src/calc.ts", `${CALC}// naive\n`)
-        r.write("src/calc.test.ts", ACCEPTANCE)
-      },
-      "seam.check": () => undefined,
-      "seam.judge": () => '[{"id":"shape","answer":"land","p":0.9}]',
-      "implement.building": (_: unknown, r: typeof repo) =>
-        r.write("src/calc.ts", `${CALC}// built\n`),
-      "implement.health.check": () => undefined,
-      "implement.closing": runsItsScript,
-      "build.review.reviewing": (_: unknown, r: typeof repo) => r.write(".gtd/REVIEW.md", review()),
-    }
-    expect((await repo.drive(lap)).state).toBe("build.review.await-review")
-
-    repo.write(".gtd/REVIEW.md", review("also export multiply"))
-    await repo.land()
-    const collected = await repo.drive({
-      "build.review.collecting": (_, r) => {
-        requirements(_, r)
-        r.write(".gtd/REVIEW.md", `${review("also export multiply")}    - A: noted.\n`)
-      },
-    })
-    expect(collected.state).toBe("build.review.await-review")
-
-    repo.write(".gtd/REVIEW.md", review())
-    await repo.land()
-    const rest = await repo.drive({
-      "build.review.closing": runsItsScript,
-      "re-unwind": runsItsScript,
-      "design.triage": (_, r) =>
-        r.write(
-          ".gtd/REQUIREMENTS.md",
-          "# Requirements\n\n- multiply\n\n## Acceptance Criteria\n\n- AC-1: done\n",
-        ),
-      "design.gate.answer": () => undefined,
-    })
-    expect(rest.state).toBe("implement.building")
-    expect(rest.content).toContain("already exists")
-    expect(rest.content).not.toContain("write the change fresh")
-    const subjects = repo.subjects()
-    const reUnwind = subjects.findIndex((subject) => subject.endsWith("→ re-unwind"))
-    expect(reUnwind).toBeGreaterThan(-1)
-    expect(subjects.slice(reUnwind + 1).some((subject) => subject.includes("seam."))).toBe(false)
-    expect(subjects.filter((subject) => subject.includes("→ seam.naive"))).toHaveLength(1)
-  })
-})
-
 describe("afterTail feedback lap", () => {
   const TAIL = [
     `import { start } from "@pmelab/gtd/flows"`,