@pmelab/gtd 48.0.0 → 50.0.0

package/src/steering/review.test.ts

@@ -1276,6 +1276,33 @@ describe("review.view", () => {
     expect(view.nodes[1]!.detail).toBe("")
   })
 
+  it("shows a chunk's leading severity line as its status, not its prose", () => {
+    const view = review.view(
+      [
+        "# Review: abc1234",
+        "",
+        "## Ranked",
+        "",
+        "_critical: security, one-way door_",
+        "",
+        "The new export.",
+        "",
+        "- [ ] ./a.ts#1-1",
+        "",
+        "## Unranked",
+        "",
+        "_emphasis, not a tier_",
+        "",
+        "- [ ] ./a.ts#2-2",
+        "",
+      ].join("\n"),
+    )
+    expect(view.nodes.map((c) => [c.status, c.detail])).toEqual([
+      ["critical: security, one-way door", "The new export."],
+      [undefined, "_emphasis, not a tier_"],
+    ])
+  })
+
   it("is built from one parse of the document, not one per element", () => {
     const uniqueContent = [
       "# Review: def4567",
@@ -1706,6 +1733,29 @@ describe("reviewNotes", async () => {
     expect(reviewNotes(base, base)).toEqual([])
   })
 
+  it("an edited tier line is a note", () => {
+    const was = doc("_could_\n\nProse.")
+    const after = doc("_critical: this leaks the token_\n\nProse.")
+    expect(reviewNotes(was, after)).toMatchObject([
+      {
+        kind: "chunk",
+        before: "Prose.\n\n_could_",
+        text: "Prose.\n\n_critical: this leaks the token_",
+      },
+    ])
+  })
+
+  it("prose added under a tier is the human's alone, and a leading ! still forces", () => {
+    const was = doc("_could_\n\nProse.")
+    expect(reviewNotes(was, doc("_could_\n\n! Not here.\n\nProse."))).toMatchObject([
+      { kind: "chunk", text: "! Not here. Prose.", forced: true },
+    ])
+  })
+
+  it("a deleted tier line asks nothing", () => {
+    expect(reviewNotes(doc("_could_\n\nProse."), base)).toEqual([])
+  })
+
   it("a pointer note added", () => {
     const after = doc("Prose.").replace("#1-3", "#1-3 rename this")
     expect(reviewNotes(base, after)).toEqual([
@@ -1840,6 +1890,43 @@ describe("reviewRisks", async () => {
   })
 })
 
+describe("reviewChunks", async () => {
+  const { reviewChunks } = await import("./review.js")
+
+  it("counts each chunk's pointers, a chunk of prose and answer boxes holding none", () => {
+    const content = [
+      "# Review: abc1234",
+      "",
+      "<!-- base: abc1234def5678901234567890123456789abcd -->",
+      "",
+      "## Walkthrough",
+      "",
+      "- [ ] ./src/a.ts#1-3 — first",
+      "- [ ] ./src/b.ts#4-6 — second",
+      "",
+      "## Fixed automatically",
+      "",
+      "Tick exactly one:",
+      "",
+      "- [ ] fix as suggested",
+      "- [ ] won't fix",
+      "- [ ] _your answer_",
+    ].join("\n")
+    expect(reviewChunks(content)).toEqual([
+      {
+        title: "Walkthrough",
+        line: 4,
+        pointers: 2,
+        files: [
+          { path: "./src/a.ts", line: 1, rangeEnd: 3 },
+          { path: "./src/b.ts", line: 4, rangeEnd: 6 },
+        ],
+      },
+      { title: "Fixed automatically", line: 9, pointers: 0, files: [] },
+    ])
+  })
+})
+
 describe("answer boxes", async () => {
   const { reviewDecisions, reviewNotes, unansweredNotes } = await import("./review.js")
   const note = (title: string, boxes: readonly [string, string, string]): string =>

package/src/steering/review.ts

@@ -77,6 +77,8 @@ interface Changeset {
   readonly headingLine: number
   /** The chunk's answer boxes, when gtd gave it some. */
   readonly answers?: readonly AnswerOption[]
+  /** The tier and reason gtd ranked the chunk with, from its leading severity line. */
+  readonly severity?: { readonly label: string; readonly line: number }
 }
 
 interface AnswerOption {
@@ -89,6 +91,10 @@ export const ANSWER_LEAD = "Tick exactly one:"
 export const ANSWER_FIX = "fix as suggested"
 export const ANSWER_WONT_FIX = "won't fix"
 
+/** A chunk's leading `_critical: security_` paragraph: the tier gtd ranked it with, and why. */
+const SEVERITY_LINE_RE = /^_((?:critical|should|could)(?::[^_\n]*)?)_$/
+export const severityLine = (label: string): string => `_${label}_`
+
 interface ReviewDoc {
   readonly shortHash?: string
   readonly fullHash?: string
@@ -521,6 +527,26 @@ const answerListOf = (
   return { lead, list, options }
 }
 
+/** A leading severity line is the chunk's tier, never its prose. */
+const splitSeverity = (
+  content: string,
+  run: readonly RootContent[],
+): {
+  readonly severity?: { readonly label: string; readonly line: number } | undefined
+  readonly leadingRun: readonly RootContent[]
+} => {
+  const first = run[0]
+  const label =
+    first?.type === "paragraph"
+      ? SEVERITY_LINE_RE.exec(sourceText(content, first).trim())?.[1]
+      : undefined
+  if (label === undefined) return { leadingRun: run }
+  return {
+    severity: { label, line: toLspPosition(first!.position!.start).line },
+    leadingRun: run.slice(1),
+  }
+}
+
 /** Splits one chunk's body nodes into its file pointers (hunk pointers are task items, collected recursively at ANY nesting depth via `taskItems` — a nested hunk is the same kind of hunk as a top-level one) and description prose. The description is the chunk's own leading run and never a node that contains a hunk pointer: it stops at the first node whose `taskItems` include a real pointer (at any depth — a blockquote wrapping a pointer list stops it just as a top-level list would). Every node kind in what's left before that point contributes — a `footnoteDefinition` is the one exception, excluded by `blockNodesOfRun` itself (it's a note, never document content). */
 const parseChunkBody = (
   content: string,
@@ -534,6 +560,7 @@ const parseChunkBody = (
   readonly files: readonly ReviewFile[]
   readonly errors: readonly SteeringFinding[]
   readonly answers?: readonly AnswerOption[]
+  readonly severity?: { readonly label: string; readonly line: number } | undefined
   /** Whether a task box outside the answer list exists. */
   readonly boxed: boolean
 } => {
@@ -543,9 +570,10 @@ const parseChunkBody = (
   const firstPointerIndex = body.findIndex(
     (n) => !isAnswer(n) && taskItems(n).some((item) => hasPointerToken(content, item)),
   )
-  const leadingRun = (firstPointerIndex === -1 ? body : body.slice(0, firstPointerIndex)).filter(
+  const run = (firstPointerIndex === -1 ? body : body.slice(0, firstPointerIndex)).filter(
     (n) => !isAnswer(n),
   )
+  const { severity, leadingRun } = splitSeverity(content, run)
   const descriptionNodes = blockNodesOfRun(content, leadingRun)
   const descriptionInline = collapseImages(blockRunInline(content, leadingRun))
   const description = leadingRun
@@ -569,6 +597,7 @@ const parseChunkBody = (
     files,
     errors,
     ...(answer === undefined ? {} : { answers: answer.options }),
+    ...(severity === undefined ? {} : { severity }),
     boxed: body.some((n) => !isAnswer(n) && taskItems(n).length > 0),
   }
 }
@@ -618,6 +647,7 @@ const parseChangesets = (
       descriptionInline,
       files,
       answers,
+      severity,
       boxed,
       errors: bodyErrors,
     } = parseChunkBody(content, lines, title, body)
@@ -638,6 +668,7 @@ const parseChangesets = (
       files,
       headingLine,
       ...(answers === undefined ? {} : { answers }),
+      ...(severity === undefined ? {} : { severity }),
     })
   }
   if (changesets.length === 0) errors.push({ message: "REVIEW.md has no '##' chunks" })
@@ -997,6 +1028,7 @@ const reviewView = (content: string): SteeringView => {
       detail: chunk.description,
       detailInline: chunk.descriptionInline,
       body: chunk.descriptionNodes,
+      ...(chunk.severity === undefined ? {} : { status: chunk.severity.label }),
       anchor: { kind: "chunk", index: chunkIndex },
       ...noteAt(chunk.headingLine),
       children: chunk.files.map((file, index) => ({
@@ -1177,11 +1209,22 @@ const pointerLabel = (f: ReviewFile): string =>
 
 type Found = { line: number; note: Omit<ReviewNote, "id" | "forced"> }
 
-// A chunk added with its own answer boxes (a driver's imported note) is
-// answered by its tick, never judged as prose as well.
-const chunkNote = (chunk: Changeset, prior: Changeset | undefined): Found[] =>
-  chunk.description === (prior?.description ?? "") ||
-  (prior === undefined && chunk.answers !== undefined)
+// Rewording a tier disputes it, so a changed tier joins the note — after the
+// prose, so a leading `!` still forces; deleting one asks nothing.
+const chunkProse = (chunk: Changeset | undefined, retiered: boolean): string =>
+  [
+    chunk?.description ?? "",
+    retiered && chunk?.severity !== undefined ? severityLine(chunk.severity.label) : "",
+  ]
+    .filter((p) => p !== "")
+    .join("\n\n")
+
+const chunkNote = (chunk: Changeset, prior: Changeset | undefined): Found[] => {
+  const retiered = chunk.severity !== undefined && chunk.severity.label !== prior?.severity?.label
+  // A chunk added with its own answer boxes (a driver's imported note) is
+  // answered by its tick, never judged as prose as well.
+  return chunkProse(chunk, retiered) === chunkProse(prior, retiered) ||
+    (prior === undefined && chunk.answers !== undefined)
     ? []
     : [
         {
@@ -1189,11 +1232,12 @@ const chunkNote = (chunk: Changeset, prior: Changeset | undefined): Found[] =>
           note: {
             kind: "chunk",
             anchor: chunk.title,
-            before: prior?.description ?? "",
-            text: chunk.description,
+            before: chunkProse(prior, retiered),
+            text: chunkProse(chunk, retiered),
           },
         },
       ]
+}
 
 const pointerNotes = (chunk: Changeset, prior: Changeset | undefined): Found[] =>
   chunk.files.flatMap((file): Found[] => {
@@ -1338,3 +1382,26 @@ export const reviewDecisions = (before: string, after: string): readonly ReviewD
     return old?.choice === decision.choice && old.text === decision.text ? [] : [decision]
   })
 }
+
+/** Each `##` chunk in document order: its title, 0-based heading line and how many hunk pointers it holds. */
+export const reviewChunks = (
+  content: string,
+): readonly {
+  title: string
+  line: number
+  pointers: number
+  /** 0-based line of the chunk's severity line, when it has one. */
+  severityLine?: number
+  files: readonly { path: string; line?: number; rangeEnd?: number }[]
+}[] =>
+  parseReviewDoc(content).changesets.map((c) => ({
+    title: c.title,
+    line: c.headingLine,
+    pointers: c.files.length,
+    ...(c.severity === undefined ? {} : { severityLine: c.severity.line }),
+    files: c.files.map((f) => ({
+      path: f.path,
+      ...(f.line === undefined ? {} : { line: f.line }),
+      ...(f.rangeEnd === undefined ? {} : { rangeEnd: f.rangeEnd }),
+    })),
+  }))

package/src/workflows/feature/coverage.feature

@@ -61,13 +61,13 @@ Feature: a feature is done only when every acceptance criterion has a passing te
       [{"id":"AC-1","answer":"yes","p":0.9},{"id":"AC-2","answer":"yes","p":0.9}]
       """
     When the process is driven
-    Then the process rests at "build.review.composing"
+    Then the process rests at "build.review.reviewing"
     And the commit subjects end with:
       """
       gtd(check): implement.applying → implement.health.check
       gtd(check): implement.health.check → implement.coverage
       gtd(judge): implement.coverage → implement.closing
-      gtd(check): implement.closing → build.review.composing
+      gtd(check): implement.closing → build.review.reviewing
       """
     And the commit "gtd(judge): implement.coverage → implement.closing" has a body containing "Gtd-Mark: covers=AC-1"
     And the commit "gtd(judge): implement.coverage → implement.closing" has a body containing "Gtd-Mark: covers=AC-2"
@@ -144,7 +144,7 @@ Feature: a feature is done only when every acceptance criterion has a passing te
       """
     And step "implement.uncovered" changes nothing
     When the process is driven
-    Then the process rests at "build.review.composing"
+    Then the process rests at "build.review.reviewing"
     And the commit "gtd(human): implement.uncovered → implement.closing" has a body containing "Gtd-Mark: covers=AC-1"
     And the commit "gtd(human): implement.uncovered → implement.closing" has a body containing "Gtd-Mark: uncovered=AC-2"
 

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

@@ -64,7 +64,7 @@ Feature: a trivial change takes the same few beats at either risk tier
       """
     And step "implement.applying" runs its script
     When the process is driven
-    Then the process rests at "build.review.composing"
+    Then the process rests at "build.review.reviewing"
     And "src/greeting.ts" contains "Hello, world"
     And the commit subjects end with:
       """
@@ -80,7 +80,7 @@ Feature: a trivial change takes the same few beats at either risk tier
       gtd(check): implement.health.check → implement.coverage
       gtd(judge): implement.coverage → implement.closing
       gtd(check): implement.closing → build.quality.correctness.reviewing
-      gtd(agent): build.quality.correctness.reviewing → build.review.composing
+      gtd(agent): build.quality.correctness.reviewing → build.review.reviewing
       """
     And the output of gtd "summary" <summary> "needs a human reviewer"
 

package/src/workflows/feature/feature.ts

@@ -38,7 +38,8 @@ import { recordRisk, riskTierOn, type RiskTier } from "./tier.js"
 // judged with `flagMode` on: it lands as the implementation, or (refactoring
 // first when the judge asks) is built fresh from → the health loop → the
 // triaged quality lap, whose leftovers are carried on → after the last slice,
-// human review of the whole change and every slice's findings, which
+// a reviewer's walkthrough of the whole change, every slice's findings
+// among its chunks, for the human, which
 // signs off (the episode ends back at `idle`) or sends a design → implement
 // lap.
 
@@ -152,11 +153,15 @@ const buildSlice = async (sliceBase: string, build: SliceBuild): Promise<void> =
   })
 }
 
-/** The quality lap of slice `last.slice`, then the human review since `base`, listing what earlier slices' `laps` left too. */
+/**
+ * The quality lap of slice `last.slice`, then a reviewer's walkthrough since
+ * `base` for the human, carrying what earlier slices' `laps` left too.
+ */
 const reviewedTail = (
   base: string,
   lensBase: string,
   last: { readonly slice: string; readonly laps: SliceBuild["laps"] } = { slice: "", laps: [] },
+  lap: "first" | "feedback" = "first",
 ): Promise<ReviewOutcome> =>
   tail(
     (escalations, report) =>
@@ -165,6 +170,8 @@ const reviewedTail = (
           last.laps.length === 0
             ? report
             : joinReports([...last.laps, { slice: last.slice, report }]),
+        walkthrough: true,
+        lap,
       }),
     { green: true, lensBase },
   )
@@ -189,7 +196,7 @@ const featureFeedback = async (
     })
     const tier = riskTierOn() ? recordRisk() : undefined
     closed = await implementing({ tier, amend: true })
-    outcome = await reviewedTail(outcome.base, lensBase)
+    outcome = await reviewedTail(outcome.base, lensBase, undefined, "feedback")
   }
 }
 

package/src/workflows/feature/flag-mode.feature

@@ -67,7 +67,7 @@ Feature: flag mode off lands the naive pass with no release flag, seam judge or
       """
     And step "build.quality.correctness.reviewing" changes nothing
     When the process is driven
-    Then the process rests at "build.review.composing"
+    Then the process rests at "build.review.reviewing"
     And "src/calc.ts" contains "subtract"
     And "src/calc.test.ts" contains "[AC-1] subtracts"
     And the commit subjects end with:
@@ -85,5 +85,5 @@ Feature: flag mode off lands the naive pass with no release flag, seam judge or
       gtd(check): implement.health.check → implement.coverage
       gtd(judge): implement.coverage → implement.closing
       gtd(check): implement.closing → build.quality.correctness.reviewing
-      gtd(agent): build.quality.correctness.reviewing → build.review.composing
+      gtd(agent): build.quality.correctness.reviewing → build.review.reviewing
       """

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

@@ -1,12 +1,11 @@
 @inmem
-Feature: the quality lenses are the only agentic review
+Feature: the quality lap's findings are triaged before the review
 
   A judge classifies each `## ` finding the lenses wrote to `.gtd/QUALITY.md`:
   a mechanical one is fixed by the fixer, noise is dropped with its `p` kept in
   a trailer, and a design one becomes a note in `.gtd/REVIEW.md`, with answer
-  boxes. gtd writes that file itself — no reviewer turn runs — and lists,
-  without tick boxes, what was fixed automatically and what was dropped as
-  noise.
+  boxes, in the chunk the reviewer gave it. gtd lists, without tick boxes,
+  what was fixed automatically and what was dropped as noise.
 
   Background:
     Given the shipped workflows, as gtd install scaffolds them
@@ -75,7 +74,11 @@ Feature: the quality lenses are the only agentic review
       """
     And step "build.quality.sorting" runs its script
     And step "build.quality.closing" runs its script
-    And step "build.review.composing" runs its script
+    And step "build.review.carrying" runs its script
+    And judge step "build.review.ranking" answers:
+      """
+      []
+      """
 
   Scenario: a mechanical finding is fixed and listed, noise dropped and listed, a design one noted
     Given judge step "build.quality.triage" answers:
@@ -89,6 +92,20 @@ Feature: the quality lenses are the only agentic review
       """
     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 — subtract(a, b)
+
+      ## 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.await-review"
     And ".gtd/QUALITY.md" does not exist
@@ -97,8 +114,14 @@ Feature: the quality lenses are the only agentic review
       """
       ## AC-1 ignores floating point
 
+      _critical: judge unsure_
+
       Should subtract round? The criterion does not say.
 
+      In the code:
+
+      - [ ] ./src/calc.ts#2-2 — where it applies
+
       Tick exactly one:
 
       - [ ] fix as suggested
@@ -129,8 +152,10 @@ Feature: the quality lenses are the only agentic review
       gtd(judge): build.quality.triage → build.quality.sorting
       gtd(check): build.quality.sorting → build.fix.quality.fixing
       gtd(agent): build.fix.quality.fixing → build.health.check
-      gtd(check): build.health.check → build.review.composing
-      gtd(check): build.review.composing → build.review.await-review
+      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
@@ -138,6 +163,28 @@ Feature: the quality lenses are the only agentic review
       """
       [{"id":"Q1","answer":"mechanical","p":0.5},{"id":"Q2","answer":"noise","p":0.6}]
       """
+    And step "build.review.reviewing" writes ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## Subtract
+
+      - [ ] ./src/calc.ts#2-2 — subtract(a, b)
+
+      ## subtract has no negative test
+
+      - [ ] ./src/calc.ts#2-2 — where it applies
+
+      ## add could be a method
+
+      - [ ] ./src/calc.ts#2-2 — where it applies
+
+      ## 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.await-review"
     And ".gtd/REVIEW.md" contains "## subtract has no negative test"
@@ -148,8 +195,10 @@ Feature: the quality lenses are the only agentic review
     And the commit subjects end with:
       """
       gtd(judge): build.quality.triage → build.quality.sorting
-      gtd(check): build.quality.sorting → build.review.composing
-      gtd(check): build.review.composing → build.review.await-review
+      gtd(check): build.quality.sorting → 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 mechanical finding the fix cap leaves becomes a note
@@ -166,6 +215,20 @@ Feature: the quality lenses are the only agentic review
       A class would read better.
       """
     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 — subtract(a, b)
+
+      ## add could be a method
+
+      - [ ] ./src/calc.ts#2-2 — where it applies
+      """
     When the process is driven
     Then the process rests at "build.review.await-review"
     And ".gtd/QUALITY.md" does not exist
@@ -173,6 +236,8 @@ Feature: the quality lenses are the only agentic review
       """
       ## add could be a method
 
+      _critical: judge unsure_
+
       _The fixer left this unresolved._
 
       A class would read better.
@@ -186,8 +251,10 @@ Feature: the quality lenses are the only agentic review
       gtd(agent): build.fix.quality.fixing
       gtd(agent): build.fix.quality.fixing → build.health.check
       gtd(check): build.health.check → build.quality.closing
-      gtd(check): build.quality.closing → build.review.composing
-      gtd(check): build.review.composing → build.review.await-review
+      gtd(check): build.quality.closing → 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 fixer that renames a chunk it leaves counts nothing fixed
@@ -204,6 +271,32 @@ Feature: the quality lenses are the only agentic review
       Still open.
       """
     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 — subtract(a, b)
+
+      ## subtract has no negative test
+
+      - [ ] ./src/calc.ts#2-2 — where it applies
+
+      ## add could be a method
+
+      - [ ] ./src/calc.ts#2-2 — where it applies
+
+      ## AC-1 ignores floating point
+
+      - [ ] ./src/calc.ts#2-2 — where it applies
+
+      ## null check in parse()
+
+      - [ ] ./src/calc.ts#2-2 — where it applies
+      """
     When the process is driven
     Then the process rests at "build.review.await-review"
     And ".gtd/REVIEW.md" contains "## null check in parse()"
@@ -223,17 +316,37 @@ Feature: the quality lenses are the only agentic review
       All fixed.
       """
     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 — subtract(a, b)
+      """
     When the process is driven
     Then the process rests at "build.review.await-review"
     And ".gtd/REVIEW.md" contains "- subtract has no negative test ("
     And ".gtd/REVIEW.md" does not contain "check whether it was fixed"
 
-  Scenario: signing off a composed review ends the process
+  Scenario: signing off a review with no notes ends the process
     Given judge step "build.quality.triage" answers:
       """
       [{"id":"Q1","answer":"noise","p":0.9},{"id":"Q2","answer":"noise","p":0.9},{"id":"Q3","answer":"noise","p":0.9}]
       """
     And step "build.review.closing" runs its script
+    And step "build.review.reviewing" writes ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## Subtract
+
+      - [ ] ./src/calc.ts#2-2 — subtract(a, b)
+      """
     When the process is driven
     Then the process rests at "build.review.await-review"
     When gtd lands
@@ -242,7 +355,9 @@ Feature: the quality lenses are the only agentic review
     And ".gtd/REVIEW.md" does not exist
     And the commit subjects end with:
       """
-      gtd(check): build.review.composing → build.review.await-review
+      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
       gtd(human): build.review.await-review → build.review.closing
       gtd(check): build.review.closing → idle
       """

package/src/workflows/feature/one-step-land.feature

@@ -64,7 +64,7 @@ Feature: a naive pass the judge rules land is itself the implementation
 
   Scenario: a land judgment applies the naive pass and runs from idle to the review gate with no rebuild
     When the process is driven
-    Then the process rests at "build.review.composing"
+    Then the process rests at "build.review.reviewing"
     And "src/greeting.ts" contains "Hello, world"
     And "src/acceptance.test.ts" contains "[AC-1] holds"
     And the commit subjects end with:
@@ -81,7 +81,7 @@ Feature: a naive pass the judge rules land is itself the implementation
       gtd(check): implement.health.check → implement.coverage
       gtd(judge): implement.coverage → implement.closing
       gtd(check): implement.closing → build.quality.correctness.reviewing
-      gtd(agent): build.quality.correctness.reviewing → build.review.composing
+      gtd(agent): build.quality.correctness.reviewing → build.review.reviewing
       """
     And the commit "gtd(human): idle → unwind" has a body containing "Gtd-Var: flag_risk_tier=0"
     And the commit "gtd(agent): seam.naive → seam.check" has a body containing "Gtd-Kept:"

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

@@ -113,7 +113,7 @@ Feature: a refactor that carried the whole feature still gets a quality lap over
 
     Given step "build.quality.correctness.reviewing" changes nothing
     When the process is driven
-    Then the process rests at "build.review.composing"
+    Then the process rests at "build.review.reviewing"
     And "src/calc.ts" contains "subtract"
     And the commit subjects end with:
       """
@@ -123,7 +123,7 @@ Feature: a refactor that carried the whole feature still gets a quality lap over
       gtd(check): implement.health.check → implement.coverage
       gtd(judge): implement.coverage → implement.closing
       gtd(check): implement.closing → build.quality.correctness.reviewing
-      gtd(agent): build.quality.correctness.reviewing → build.review.composing
+      gtd(agent): build.quality.correctness.reviewing → build.review.reviewing
       """
     And the output lines of gtd "slices" start with:
       """