@pmelab/gtd 34.0.0 → 36.0.0

package/src/workflows/feature/feature.ts

@@ -17,14 +17,15 @@ import * as t from "../shared/text.js"
 import { skipDesign, statedCriteria, type StatedCriteria } from "./criteria.js"
 import { design } from "./planning.js"
 import { buildTail, isCode, reUnwind, type ReviewOutcome } from "./review.js"
-import { implement, seamBuild, type SeamOutcome } from "./seam.js"
+import { implement, seamBuild } from "./seam.js"
 import { recordRisk, riskTierOn } from "./tier.js"
 
 // The ordinary start. Any change to the tree starts a process: `idle` →
 // `unwind` reverts the sketch (its intent survives in history) → a
-// green-baseline gate → design → a judged naive pass (refactoring first when
-// the judge asks; with `flagMode` off, neither) → implement → the quality lap,
-// and the episode ends back at `idle`. Human review is the `review` door's.
+// green-baseline gate → design → a naive pass, judged with `flagMode` on: it
+// lands as the implementation, or (refactoring first when the judge asks) is
+// built fresh from → the health loop → the quality lap, and the episode ends
+// back at `idle`. Human review is the `review` door's.
 
 /** Revert the sketch that started the process out of the working tree; its intent survives in history. */
 export const unwind = (): Promise<void> => {
@@ -36,14 +37,17 @@ export const unwind = (): Promise<void> => {
 
 export { reUnwind }
 
-/** A judged naive pass (none with `flagMode` off), then implement and the quality lap; design must have run since `firstBase`. */
+/** A naive pass (judged only with `flagMode` on), then implement and the quality lap; design must have run since `firstBase`. */
 export const buildFeature = async (firstBase: string): Promise<void> => {
   const tier = riskTierOn() ? recordRisk() : undefined
-  const seam: Omit<SeamOutcome, "reference"> & { reference?: string } = flagModeOn()
-    ? await seamBuild(firstBase)
-    : { base: firstBase }
+  const seam = await seamBuild(firstBase)
   await slice("feature", async () => {
-    await implement({ reference: seam.reference, tier, afterRefactor: seam.refactored })
+    await implement({
+      reference: seam.reference,
+      tier,
+      afterRefactor: seam.refactored,
+      naive: seam.land === true ? seam.reference : undefined,
+    })
     // An empty feature slice: the refactor carried the feature, so the lap covers the whole change.
     const base =
       seam.refactored === true && !changesSince(seam.base).some((c) => isCode(c.path))

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

@@ -1,9 +1,9 @@
 @inmem
-Feature: flag mode off builds a feature with no release flag, seam judge or refactor
+Feature: flag mode off lands the naive pass with no release flag, seam judge or refactor
 
   `flagMode` is a factory option of the shipped workflows, on by default. Off,
   the project ships without feature flags: no seam judge and no refactor run,
-  and the naive implementation goes straight through the health loop and the
+  and the naive pass itself lands, straight through the health loop and the
   quality lap.
 
   Background:
@@ -43,23 +43,33 @@ Feature: flag mode off builds a feature with no release flag, seam judge or refa
       """
     And step "design.gate.answer" changes nothing
 
-  Scenario: flag mode off skips the seam judge and the refactor, and asks for no flag
+  Scenario: flag mode off lands the naive pass unjudged, and asks for no flag
     When the process is driven
-    Then the process rests at "implement.building"
+    Then the process rests at "seam.naive"
     And the resting step's content contains "the quickest way that works"
-    And the resting step's content contains "Add no release flag — this project ships without release flags"
-    And the resting step's content does not contain "new release flag"
-    Given step "implement.building" writes "src/calc.ts" with:
+    And the resting step's content does not contain "release flag"
+    Given step "seam.naive" writes "src/calc.test.ts" with:
+      """
+      it("[AC-1] subtracts", () => {})
+      """
+    And step "seam.naive" writes "src/calc.ts" with:
       """
       export const add = (a: number, b: number) => a + b
       export const subtract = (a: number, b: number) => a - b
       """
+    And step "seam.check" changes nothing
+    And step "implement.applying" runs its script
     And step "implement.health.check" changes nothing
     And step "implement.closing" runs its script
+    And judge step "implement.coverage" answers:
+      """
+      [{"id":"AC-1","answer":"yes","p":0.9}]
+      """
     And step "build.quality.correctness.reviewing" changes nothing
     When the process is driven
     Then the process rests at "idle"
     And "src/calc.ts" contains "subtract"
+    And "src/calc.test.ts" contains "[AC-1] subtracts"
     And the commit subjects end with:
       """
       chore: initial commit
@@ -68,9 +78,12 @@ Feature: flag mode off builds a feature with no release flag, seam judge or refa
       gtd(check): unwind → start-gate.check
       gtd(check): start-gate.check → design.triage
       gtd(agent): design.triage → design.gate.answer
-      gtd(human): design.gate.answer → implement.building
-      gtd(agent): implement.building → implement.health.check
-      gtd(check): implement.health.check → implement.closing
+      gtd(human): design.gate.answer → seam.naive
+      gtd(agent): seam.naive → seam.check
+      gtd(check): seam.check → implement.applying
+      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.quality.correctness.reviewing
       gtd(agent): build.quality.correctness.reviewing → idle
       """

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

@@ -37,13 +37,23 @@ Feature: each quality lens runs on its own model hint
       - AC-1: `subtract(a, b)` returns `a - b`.
       """
     And step "design.gate.answer" changes nothing
-    And step "implement.building" writes "src/calc.ts" with:
+    And step "seam.naive" writes "src/calc.test.ts" with:
+      """
+      it("[AC-1] subtracts", () => {})
+      """
+    And step "seam.naive" writes "src/calc.ts" with:
       """
       export const add = (a: number, b: number) => a + b
       export const subtract = (a: number, b: number) => a - b
       """
+    And step "seam.check" changes nothing
+    And step "implement.applying" runs its script
     And step "implement.health.check" changes nothing
     And step "implement.closing" runs its script
+    And judge step "implement.coverage" answers:
+      """
+      [{"id":"AC-1","answer":"yes","p":0.9}]
+      """
 
   Scenario: a hinted lens runs on its hint, every other lens on its default
     When the process is driven

package/src/workflows/feature/naive-acceptance.feature

@@ -129,12 +129,12 @@ Feature: a naive pass ends only when a test names every criterion and the suite
       """
     And step "seam.check" from now on changes nothing
     When the process is driven
-    Then the process rests at "implement.building"
+    Then the process rests at "implement.applying"
     And the commit subjects end with:
       """
       gtd(human): design.gate.answer → seam.naive
       gtd(agent): seam.naive → seam.check
       gtd(check): seam.check → seam.naive
       gtd(agent): seam.naive → seam.check
-      gtd(check): seam.check → implement.building
+      gtd(check): seam.check → implement.applying
       """

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

@@ -1,11 +1,11 @@
 # One SDLC path per file, so a changed path reds exactly one fixture — do not merge.
 @inmem
-Feature: a naive pass the judge rules land goes straight to implement with no seam gate
+Feature: a naive pass the judge rules land is itself the implementation
 
   With GTD_FLAG_RISK_TIER off, a naive pass that
   edits an existing source file is judged land: the process skips the approval
-  gate and any refactor, and runs implement and quality
-  back to idle, with no review. The flag is pinned here so the per-flag test runs never
+  gate and any refactor, applies the kept pass as it is — no build turn — and
+  runs the health loop and quality back to idle, with no review. The flag is pinned here so the per-flag test runs never
   move it off this path.
 
   Background:
@@ -53,18 +53,20 @@ Feature: a naive pass the judge rules land goes straight to implement with no se
       """
       [{"id":"shape","answer":"land","p":0.9}]
       """
-    And step "implement.building" writes "src/greeting.ts" with:
-      """
-      export const greeting = "Hello, world!"
-      """
+    And step "implement.applying" runs its script
     And step "implement.health.check" changes nothing
     And step "implement.closing" runs its script
+    And judge step "implement.coverage" answers:
+      """
+      [{"id":"AC-1","answer":"yes","p":0.9}]
+      """
     And step "build.quality.correctness.reviewing" changes nothing
 
-  Scenario: a land judgment runs idle to idle with no seam gate or refactor
+  Scenario: a land judgment applies the naive pass and runs idle to idle with no rebuild
     When the process is driven
     Then the process rests at "idle"
-    And "src/greeting.ts" contains "Hello, world!"
+    And "src/greeting.ts" contains "Hello, world"
+    And "src/acceptance.test.ts" contains "[AC-1] holds"
     And the commit subjects end with:
       """
       gtd(human): idle → unwind
@@ -74,15 +76,16 @@ Feature: a naive pass the judge rules land goes straight to implement with no se
       gtd(human): design.gate.answer → seam.naive
       gtd(agent): seam.naive → seam.check
       gtd(check): seam.check → seam.judge
-      gtd(judge): seam.judge → implement.building
-      gtd(agent): implement.building → implement.health.check
-      gtd(check): implement.health.check → implement.closing
+      gtd(judge): seam.judge → implement.applying
+      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.quality.correctness.reviewing
       gtd(agent): build.quality.correctness.reviewing → idle
       """
     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:"
-    And the commit "gtd(judge): seam.judge → implement.building" has a body containing "\"answer\":\"land\""
+    And the commit "gtd(judge): seam.judge → implement.applying" has a body containing "\"answer\":\"land\""
     And no commit body contains "Gtd-Approved:"
     And the output lines of gtd "slices" start with:
       """

package/src/workflows/feature/quality-unresolved.feature

@@ -37,13 +37,23 @@ Feature: quality findings left unresolved hold a feature process short of idle
       - AC-1: subtract(a, b) returns a - b.
       """
     And step "design.gate.answer" changes nothing
-    And step "implement.building" writes "src/calc.ts" with:
+    And step "seam.naive" writes "src/calc.test.ts" with:
+      """
+      it("[AC-1] subtracts", () => {})
+      """
+    And step "seam.naive" writes "src/calc.ts" with:
       """
       export const add = (a: number, b: number) => a + b
       export const subtract = (a: number, b: number) => a - b
       """
+    And step "seam.check" changes nothing
+    And step "implement.applying" runs its script
     And step "implement.health.check" changes nothing
     And step "implement.closing" runs its script
+    And judge step "implement.coverage" answers:
+      """
+      [{"id":"AC-1","answer":"yes","p":0.9}]
+      """
 
   Scenario: findings the fix cap left unresolved rest at build.quality-unresolved
     Given step "build.quality.correctness.reviewing" writes ".gtd/QUALITY.md" with:

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

@@ -94,6 +94,10 @@ Feature: a refactor that carried the whole feature still gets a quality lap over
     And step "implement.building" changes nothing
     And step "implement.health.check" changes nothing
     And step "implement.closing" runs its script
+    And judge step "implement.coverage" answers:
+      """
+      [{"id":"AC-1","answer":"yes","p":0.9}]
+      """
     When gtd lands
     And the process is driven
     Then the process rests at "build.quality.correctness.reviewing"
@@ -109,7 +113,8 @@ Feature: a refactor that carried the whole feature still gets a quality lap over
       gtd(human): refactor.build.review.await-review → refactor.build.review.closing
       gtd(check): refactor.build.review.closing → implement.building
       gtd(agent): implement.building → implement.health.check
-      gtd(check): implement.health.check → implement.closing
+      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 → idle
       """

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

@@ -108,6 +108,10 @@ Feature: a refactor-first judgment walks one fixed path to idle
       """
     And step "implement.health.check" changes nothing
     And step "implement.closing" runs its script
+    And judge step "implement.coverage" answers:
+      """
+      [{"id":"AC-1","answer":"yes","p":0.9}]
+      """
     When the process is driven
     Then the process rests at "idle"
     And "src/calc.ts" contains "op(a, b, 1)"
@@ -130,7 +134,8 @@ Feature: a refactor-first judgment walks one fixed path to idle
       gtd(human): refactor.build.review.await-review → refactor.build.review.closing
       gtd(check): refactor.build.review.closing → implement.building
       gtd(agent): implement.building → implement.health.check
-      gtd(check): implement.health.check → implement.closing
+      gtd(check): implement.health.check → implement.coverage
+      gtd(judge): implement.coverage → implement.closing
       gtd(check): implement.closing → idle
       """
     And the commit "gtd(human): idle → unwind" has a body containing "Gtd-Var: flag_risk_tier=0"

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

@@ -347,6 +347,10 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
         """
       And step "implement.health.check" changes nothing
       And step "implement.closing" runs its script
+      And judge step "implement.coverage" answers:
+        """
+        [{"id":"AC-1","answer":"yes","p":0.9}]
+        """
       When the process is driven
       Then the process rests at "refactor.build.review.await-review"
       Given a file ".gtd/REVIEW.md" with:
@@ -636,6 +640,10 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
         """
       And step "implement.health.check" changes nothing
       And step "implement.closing" runs its script
+      And judge step "implement.coverage" answers:
+        """
+        [{"id":"AC-1","answer":"yes","p":0.9}]
+        """
       When the process is driven
       Then the process rests at "refactor.build.review.await-review"
       Given a file ".gtd/REVIEW.md" with:
@@ -711,6 +719,10 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
         """
       And step "implement.health.check" changes nothing
       And step "implement.closing" runs its script
+      And judge step "implement.coverage" answers:
+        """
+        [{"id":"AC-1","answer":"yes","p":0.9}]
+        """
       When the process is driven
       Then the process rests at "refactor.build.review.await-review"
       Given a file ".gtd/REVIEW.md" with:
@@ -973,6 +985,10 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
         """
       And step "implement.health.check" changes nothing
       And step "implement.closing" runs its script
+      And judge step "implement.coverage" answers:
+        """
+        [{"id":"AC-1","answer":"yes","p":0.9}]
+        """
       When the process is driven
       Then the process rests at "refactor.build.review.await-review"
       Given a file ".gtd/REVIEW.md" with:
@@ -1052,6 +1068,10 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
         """
       And step "implement.health.check" changes nothing
       And step "implement.closing" runs its script
+      And judge step "implement.coverage" answers:
+        """
+        [{"id":"AC-1","answer":"yes","p":0.9}]
+        """
       When the process is driven
       Then the process rests at "refactor.build.review.await-review"
       Given a file ".gtd/REVIEW.md" with:
@@ -1226,6 +1246,10 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
         """
       And step "implement.health.check" changes nothing
       And step "implement.closing" runs its script
+      And judge step "implement.coverage" answers:
+        """
+        [{"id":"AC-1","answer":"yes","p":0.9}]
+        """
       When the process is driven
       Then the process rests at "refactor.build.review.await-review"
       Given a file ".gtd/REVIEW.md" with:

package/src/workflows/feature/risk-tier.feature

@@ -133,7 +133,7 @@ Feature: the risk tier is proposed at triage and recorded behind GTD_FLAG_RISK_T
         | low  |
         | high |
 
-    Scenario: the tier comes from the requirements the final design gate lap accepted
+    Scenario: the tier a rebuilt pass is told comes from the requirements the final design gate lap accepted
       Given step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
         """
         # Requirements
@@ -146,7 +146,11 @@ Feature: the risk tier is proposed at triage and recorded behind GTD_FLAG_RISK_T
 
         - AC-1: the change behaves as described.
         """
-      And step "seam.check" changes nothing
+      And step "seam.check" writes "src/acceptance.test.ts" with:
+        """
+        it("[AC-1] holds elsewhere", () => {})
+        """
+      And step "implement.applying" runs its script
       And step "seam.naive" writes "src/acceptance.test.ts" with:
         """
         it("[AC-1] holds", () => {})
@@ -245,7 +249,7 @@ Feature: the risk tier is proposed at triage and recorded behind GTD_FLAG_RISK_T
       And the resting step's content does not contain "## Production Signals"
 
 
-    Scenario: the flag-off twin keeps today's flag demand
+    Scenario: the flag-off twin keeps today's flag demand on a rebuilt pass
       Given step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
         """
         # Requirements
@@ -259,7 +263,11 @@ Feature: the risk tier is proposed at triage and recorded behind GTD_FLAG_RISK_T
         - AC-1: the change behaves as described.
         """
       And step "design.gate.answer" changes nothing
-      And step "seam.check" changes nothing
+      And step "seam.check" writes "src/acceptance.test.ts" with:
+        """
+        it("[AC-1] holds elsewhere", () => {})
+        """
+      And step "implement.applying" runs its script
       And step "seam.naive" writes "src/acceptance.test.ts" with:
         """
         it("[AC-1] holds", () => {})

package/src/workflows/feature/seam-rejection.feature

@@ -52,6 +52,10 @@ Feature: rejected naive passes walk one fixed path through the steer gate to idl
       """
     And step "implement.health.check" changes nothing
     And step "implement.closing" runs its script
+    And judge step "implement.coverage" answers:
+      """
+      [{"id":"AC-1","answer":"yes","p":0.9}]
+      """
     When the process is driven
     Then the process rests at "seam.judge"
 
@@ -93,12 +97,7 @@ Feature: rejected naive passes walk one fixed path through the steer gate to idl
       """
       [{"id":"shape","answer":"land","p":0.9}]
       """
-    And step "implement.building" writes "src/calc.ts" with:
-      """
-      export const add = (a: number, b: number) => a + b
-      export const subtract = (a: number, b: number) => a - b
-      export const SUBTRACT = true
-      """
+    And step "implement.applying" runs its script
     When gtd lands
     And the process is driven
     Then the process rests at "idle"
@@ -121,16 +120,17 @@ Feature: rejected naive passes walk one fixed path through the steer gate to idl
       gtd(human): seam.steer → seam.naive
       gtd(agent): seam.naive → seam.check
       gtd(check): seam.check → seam.judge
-      gtd(judge): seam.judge → implement.building
-      gtd(agent): implement.building → implement.health.check
-      gtd(check): implement.health.check → implement.closing
+      gtd(judge): seam.judge → implement.applying
+      gtd(check): implement.applying → implement.health.check
+      gtd(check): implement.health.check → implement.coverage
+      gtd(judge): implement.coverage → implement.closing
       gtd(check): implement.closing → idle
       """
     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:"
     And the commit "gtd(judge): seam.judge → seam.naive" has a body containing "\"answer\":\"reject\""
     And the commit "gtd(judge): seam.judge → seam.steer" has a body containing "\"answer\":\"reject\""
-    And the commit "gtd(judge): seam.judge → implement.building" has a body containing "\"answer\":\"land\""
+    And the commit "gtd(judge): seam.judge → implement.applying" has a body containing "\"answer\":\"land\""
     And no commit body contains "Gtd-Approved:"
     And the output lines of gtd "slices" start with:
       """

package/src/workflows/feature/seam.feature

@@ -2,8 +2,8 @@
 Feature: the naive pass and seam judge decide how a feature is built
 
   After design a naive pass is set aside under a kept ref, the judge reads its
-  diff, and the process either implements straight away, refactors the seam
-  first behind a human approval, or retries the naive pass.
+  diff, and the process either applies the pass as the implementation,
+  refactors the seam first behind a human approval, or retries the naive pass.
 
   Background:
     Given the shipped workflows, as gtd install scaffolds them
@@ -50,7 +50,7 @@ Feature: the naive pass and seam judge decide how a feature is built
       """
     And step "design.gate.answer" changes nothing
 
-  Scenario: a land judgment goes straight to the implementation with no seam gate or refactor
+  Scenario: a land judgment applies the naive pass with no seam gate, refactor or build turn
     Given step "seam.check" changes nothing
     And step "seam.naive" writes "src/acceptance.test.ts" with:
       """
@@ -66,7 +66,7 @@ Feature: the naive pass and seam judge decide how a feature is built
       [{"id":"shape","answer":"land","p":0.9}]
       """
     When the process is driven
-    Then the process rests at "implement.building"
+    Then the process rests at "implement.applying"
     And the last commit body contains "Gtd-Judge:"
     And the commit subjects end with:
       """
@@ -79,27 +79,34 @@ Feature: the naive pass and seam judge decide how a feature is built
       gtd(human): design.gate.answer → seam.naive
       gtd(agent): seam.naive → seam.check
       gtd(check): seam.check → seam.judge
-      gtd(judge): seam.judge → implement.building
+      gtd(judge): seam.judge → implement.applying
       """
 
-  Scenario: config skills for the implement scope reach the implement step
-    Given step "seam.check" changes nothing
-    And step "seam.naive" writes "src/acceptance.test.ts" with:
+  Scenario: a naive pass that no longer applies is built fresh, with the implement scope's skills
+    Given step "seam.naive" writes "src/acceptance.test.ts" with:
       """
       it("[AC-1] holds", () => {})
       """
-    And step "seam.naive" writes "src/calc.ts" with:
+    And step "seam.naive" writes "src/subtract.ts" with:
       """
-      export const add = (a: number, b: number) => a + b
       export const subtract = (a: number, b: number) => a - b
       """
-    And judge step "seam.judge" answers:
+    And step "seam.check" writes "src/subtract.ts" with:
       """
-      [{"id":"shape","answer":"land","p":0.9}]
+      export const subtract = (a: number, b: number) => b - a
       """
+    And step "implement.applying" runs its script
     When the process is driven
     Then the process rests at "implement.building"
     And the resting step's content contains "my-tdd, my-runbook"
+    And the resting step's content contains "git show"
+    And ".gtd/FEEDBACK.md" contains "could not apply the naive pass"
+    And "src/subtract.ts" contains "b - a"
+    And the commit subjects end with:
+      """
+      gtd(check): seam.check → implement.applying
+      gtd(check): implement.applying → implement.building
+      """
 
   Scenario: the naive pass lands as a marker commit and its turn stays off the branch
     Given step "seam.check" changes nothing
@@ -122,7 +129,7 @@ Feature: the naive pass and seam judge decide how a feature is built
     And the commit "gtd(agent): seam.naive → seam.check" has a body containing "Gtd-Kept:"
     And "src/calc.ts" does not contain "subtract"
 
-  Scenario: the implementation is one build turn, a green check, then the requirements are closed out
+  Scenario: the implementation is the applied naive pass, a green check, then the requirements are closed out
     Given step "seam.check" changes nothing
     And step "seam.naive" writes "src/acceptance.test.ts" with:
       """
@@ -137,21 +144,22 @@ Feature: the naive pass and seam judge decide how a feature is built
       """
       [{"id":"shape","answer":"land","p":0.9}]
       """
-    And step "implement.building" writes "src/calc.ts" with:
-      """
-      export const add = (a: number, b: number) => a + b
-      export const subtract = (a: number, b: number) => a - b
-      export const SUBTRACT_ENABLED = process.env.GTD_FLAG_SUBTRACT === "1"
-      """
+    And step "implement.applying" runs its script
     And step "implement.health.check" changes nothing
     And step "implement.closing" runs its script
+    And judge step "implement.coverage" answers:
+      """
+      [{"id":"AC-1","answer":"yes","p":0.9}]
+      """
     When the process is driven
     Then the process rests at "idle"
+    And "src/calc.ts" contains "subtract"
     And the commit subjects end with:
       """
-      gtd(judge): seam.judge → implement.building
-      gtd(agent): implement.building → implement.health.check
-      gtd(check): implement.health.check → implement.closing
+      gtd(judge): seam.judge → implement.applying
+      gtd(check): implement.applying → implement.health.check
+      gtd(check): implement.health.check → implement.coverage
+      gtd(judge): implement.coverage → implement.closing
       gtd(check): implement.closing → idle
       """
     And ".gtd/REQUIREMENTS.md" does not exist
@@ -172,12 +180,12 @@ Feature: the naive pass and seam judge decide how a feature is built
       it("adds", () => expect(2 + 2).toBe(4))
       """
     When the process is driven
-    Then the process rests at "implement.building"
+    Then the process rests at "implement.applying"
     And the commit subjects end with:
       """
       gtd(human): design.gate.answer → seam.naive
       gtd(agent): seam.naive → seam.check
-      gtd(check): seam.check → implement.building
+      gtd(check): seam.check → implement.applying
       """
 
   Scenario: a naive pass adding a glob-named file does not hide a modified sibling
@@ -253,7 +261,7 @@ Feature: the naive pass and seam judge decide how a feature is built
       gtd(judge): seam.judge → seam.steer
       """
 
-  Scenario: a clean landing at the steer gate overrules, with no seam gate and no refactor
+  Scenario: a clean landing at the steer gate overrules and applies the pass, with no seam gate and no refactor
     Given step "seam.check" changes nothing
     And step "seam.naive" writes "src/acceptance.test.ts" with:
       """
@@ -270,9 +278,9 @@ Feature: the naive pass and seam judge decide how a feature is built
     When the process is driven
     Then the process rests at "seam.steer"
     When gtd lands
-    Then the process rests at "implement.building"
+    Then the process rests at "implement.applying"
     And the commit subjects end with:
       """
       gtd(judge): seam.judge → seam.steer
-      gtd(human): seam.steer → implement.building
+      gtd(human): seam.steer → implement.applying
       """

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

@@ -321,13 +321,19 @@ const driveSeam = async (
 }
 
 describe("seamBuild", () => {
-  it("land resolves the kept tip with the caller's base and enters no slice", async () => {
+  it("land resolves the kept tip to land, with the caller's base, and enters no slice", async () => {
     const h = await driveSeam("land")
-    expect(h.outcome).toEqual({ reference: "abc", base: "c-base" })
+    expect(h.outcome).toEqual({ reference: "abc", base: "c-base", land: true })
     expect(h.slices).toEqual([])
     expect(h.names).toEqual(["seam.naive", "seam.check", "seam.judge"])
   })
 
+  it("with flagMode off resolves a vetted pass to land with no judge", async () => {
+    const h = await driveSeam("reject", undefined, { flagMode: "false" })
+    expect(h.outcome).toEqual({ reference: "abc", base: "c-base", land: true })
+    expect(h.names).toEqual(["seam.naive", "seam.check"])
+  })
+
   it("a red check retries the pass, and the judge sees it only once green", async () => {
     const h = await driveSeam("land", undefined, {}, 1)
     expect(h.names).toEqual(["seam.naive", "seam.check", "seam.naive", "seam.check", "seam.judge"])
@@ -355,7 +361,7 @@ describe("seamBuild", () => {
       "seam.clear",
       "seam.judge",
     ])
-    expect(h.outcome).toEqual({ reference: "abc", base: "c-base" })
+    expect(h.outcome).toEqual({ reference: "abc", base: "c-base", land: true })
   })
 
   it("refactor-first runs the reviewed refactor in slice refactor and resolves HEAD after it", async () => {
@@ -417,7 +423,9 @@ describe("implement", () => {
         {
           step: (request: StepRequest) => {
             requests.push(request)
-            return Promise.resolve()
+            return Promise.resolve(
+              request.kind === "judge" ? { answers: {}, truncated: [] } : undefined,
+            )
           },
           pushScope: () => undefined,
           popScope: () => undefined,