@pmelab/gtd 35.0.0 → 36.0.0

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,17 +43,22 @@ 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:
@@ -64,6 +69,7 @@ Feature: flag mode off builds a feature with no release flag, seam judge or refa
     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
@@ -72,8 +78,10 @@ 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(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

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

@@ -37,11 +37,17 @@ 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:

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,10 +53,7 @@ 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:
@@ -65,10 +62,11 @@ Feature: a naive pass the judge rules land goes straight to implement with no se
       """
     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
@@ -78,8 +76,8 @@ 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(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
@@ -87,7 +85,7 @@ Feature: a naive pass the judge rules land goes straight to implement with no se
       """
     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,11 +37,17 @@ 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:

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

@@ -97,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"
@@ -125,8 +120,8 @@ 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(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
@@ -135,7 +130,7 @@ Feature: rejected naive passes walk one fixed path through the steer gate to idl
     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,12 +144,7 @@ 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:
@@ -151,10 +153,11 @@ Feature: the naive pass and seam judge decide how a feature is built
       """
     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(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
@@ -177,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
@@ -258,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:
       """
@@ -275,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 () => {

package/src/workflows/feature/seam.ts

@@ -1,7 +1,9 @@
 import { posix } from "node:path"
 import {
+  applyScript,
   changes,
   check,
+  codeChanges,
   env,
   head,
   human,
@@ -14,6 +16,7 @@ import {
   scope,
   slice,
   vars,
+  wrote,
   type Change,
   type DiffShapeResult,
   type KeptTip,
@@ -144,7 +147,7 @@ const naiveGreen = (tip: KeptTip): Promise<boolean> => {
     [
       ...paths,
       "dirty=$(git -c core.quotePath=false ls-files -m -d -o --exclude-standard)",
-      `if ! git diff --binary ${quote(`${tip.hash}^`)} ${quote(tip.hash)} -- | git apply; then`,
+      `if ! git diff --binary --no-color --no-ext-diff --no-textconv --src-prefix=a/ --dst-prefix=b/ ${quote(`${tip.hash}^`)} ${quote(tip.hash)} -- | git apply --whitespace=nowarn; then`,
       "  echo 'gtd: the kept naive pass no longer applies to HEAD; no test ran'",
       "  exit 1",
       "fi",
@@ -169,6 +172,16 @@ export interface ImplementOptions {
   readonly amend?: boolean | undefined
   /** After a refactor slice, which may already carry the feature: an empty turn completes the step. */
   readonly afterRefactor?: boolean | undefined
+  /** A kept naive tip to apply as the implementation; built fresh only when it no longer applies. */
+  readonly naive?: string | undefined
+}
+
+/** Resolves `false` when the tip no longer applies (the failure is in `.gtd/FEEDBACK.md`) or has nothing outside `.gtd/` to apply. */
+const applied = async (tip: string): Promise<boolean> => {
+  await run("applying", applyScript(tip, FEEDBACK, t.naiveApplyFailure(tip), [".gtd"]), {
+    label: "Applying the naive pass",
+  })
+  return !wrote(FEEDBACK) && codeChanges().length > 0
 }
 
 export function implement(options?: ImplementOptions): Promise<void>
@@ -186,22 +199,23 @@ export function implement(
   const options: ImplementOptions =
     typeof first === "object" && first !== null ? first : { reference: first, tier, amend }
   return scope("implement", async () => {
-    await t.agentWithSkills(
-      "building",
-      t.implementBuildingPrompt(
-        options.reference,
-        options.tier,
-        options.amend,
-        options.afterRefactor,
-        flagModeOn(),
-      ),
-      {
-        label: "Implementing",
-        model: coder(),
-        system: t.builderSystem(),
-        ...(options.afterRefactor === true ? { allowEmpty: true } : {}),
-      },
-    )
+    if (options.naive === undefined || !(await applied(options.naive)))
+      await t.agentWithSkills(
+        "building",
+        t.implementBuildingPrompt(
+          options.reference,
+          options.tier,
+          options.amend,
+          options.afterRefactor,
+          flagModeOn(),
+        ),
+        {
+          label: "Implementing",
+          model: coder(),
+          system: t.builderSystem(),
+          ...(options.afterRefactor === true ? { allowEmpty: true } : {}),
+        },
+      )
     requireCriteriaFrozen(REQUIREMENTS)
     await green()
     await requireCoverage()
@@ -211,14 +225,14 @@ export function implement(
 
 interface Decision {
   readonly reference: string
-  /** Present only on `refactor-first`: the refactor runs before the implementation. */
+  /** Absent on `land` (or with `flagMode` off, unjudged): the pass itself is the implementation. */
   readonly shape?: DiffShapeResult
 }
 
 /** Resolves `true` when the human steered (edited), `false` on a clean overrule. */
 const steer = async (retry: t.NaiveRetry): Promise<boolean> => {
   await human("steer", {
-    message: t.seamSteerMessage(retry),
+    message: t.seamSteerMessage(retry, flagModeOn()),
     label: "Steer or overrule the naive pass",
     file: REQUIREMENTS,
     acceptClean: true,
@@ -285,15 +299,19 @@ const decide = (): Promise<Decision> =>
     for (;;) {
       await naivePass(retry)
       const tip = kept("naive")!
-      const outcome = (await vetted(tip, vetting)) ?? (await ruled(tip, vetting.again))
+      const outcome =
+        (await vetted(tip, vetting)) ??
+        (flagModeOn() ? await ruled(tip, vetting.again) : { reference: tip.hash })
       if (!("kind" in outcome)) return outcome
       retry = outcome.kind === "retry" ? outcome.retry : undefined
     }
   })
 
 export interface SeamOutcome {
-  /** The naive pass's kept tip: the first implement turn's reading material. */
+  /** The naive pass's kept tip: applied as the implementation when `land`, else the first implement turn's reading material. */
   readonly reference: string
+  /** The naive pass lands as it is: no build turn. */
+  readonly land?: boolean
   /** The feature slice's base: HEAD after the refactor on refactor-first, else the caller's base. */
   readonly base: string
   readonly refactored?: boolean
@@ -301,7 +319,7 @@ export interface SeamOutcome {
 
 export const seamBuild = async (base: string): Promise<SeamOutcome> => {
   const { reference, shape } = await decide()
-  if (shape === undefined) return { reference, base }
+  if (shape === undefined) return { reference, base, land: true }
   if (shape.unreadable.length > 0) {
     await scope("seam", () =>
       human("by-hand", {

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

@@ -37,11 +37,17 @@ Feature: human review is the review door's, never the feature workflow's
       - 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:
@@ -56,8 +62,10 @@ Feature: human review is the review door's, never the feature workflow's
     And ".gtd/REVIEW.md" does not exist
     And the commit subjects end with:
       """
-      gtd(human): design.gate.answer → implement.building
-      gtd(agent): implement.building → implement.health.check
+      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 → idle
@@ -80,7 +88,7 @@ Feature: human review is the review door's, never the feature workflow's
       - [ ] ./src/calc.ts#2-2
         new subtract function
       """
-    When gtd opens door "review" with "HEAD~9"
+    When gtd opens door "review" with "HEAD~11"
     And the process is driven
     Then the process rests at "build.review.await-review"
     And the resting step's content contains the hash of the commit "feat: add calculator"

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

@@ -1059,6 +1059,14 @@ describe("the seam phase's texts", () => {
     expect(message).not.toContain("outside the expected set")
   })
 
+  it("promises no judge on an overrule with flagMode off", () => {
+    for (const retry of [{ red: "abc123" }, { fault: "acceptance-tests: x", hash: "abc123" }]) {
+      const message = renderText(() => seamSteerMessage(retry, false))
+      expect(message).not.toContain("seam judge")
+      expect(message).toContain("it lands as the implementation")
+    }
+  })
+
   it("names every unreadable path for a by-hand landing", () => {
     const message = renderText(() =>
       seamByHandMessage(["vendor/a.bin", "src/flows/helpers.ts"], ["vendor/a.bin"], "abc123"),