@pmelab/gtd 35.0.0 → 37.0.0

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

@@ -66,6 +66,10 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
       """
       [{"id":"shape","answer":"refactor-first","p":0.9}]
       """
+    And step "seam.note" writes ".gtd/REFACTOR-NOTE.md" with:
+      """
+      Seam: the existing code the strays touch.
+      """
     And step "refactor.deriving" runs its script
     And step "refactor.building" writes "src/calc.ts" with:
       """
@@ -155,6 +159,10 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
       """
       [{"id":"shape","answer":"refactor-first","p":0.9}]
       """
+    And step "seam.note" writes ".gtd/REFACTOR-NOTE.md" with:
+      """
+      Seam: the existing code the strays touch.
+      """
     And step "refactor.deriving" runs its script
     And step "refactor.building" writes "src/calc.ts" with:
       """
@@ -243,6 +251,10 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
         """
         [{"id":"shape","answer":"refactor-first","p":0.9}]
         """
+      And step "seam.note" writes ".gtd/REFACTOR-NOTE.md" with:
+        """
+        Seam: the existing code the strays touch.
+        """
       And step "refactor.deriving" runs its script
       And step "refactor.building" writes "src/calc.ts" with:
         """
@@ -345,6 +357,10 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
         export const add = (a: number, b: number) => op(a, b, 1)
         export const subtract = (a: number, b: number) => op(a, b, -1)
         """
+      And step "implement.building" writes "src/acceptance.test.ts" with:
+        """
+        it("[AC-1] holds", () => {})
+        """
       And step "implement.health.check" changes nothing
       And step "implement.closing" runs its script
       And judge step "implement.coverage" answers:
@@ -638,6 +654,10 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
         export const add = (a: number, b: number) => op(a, b, 1)
         export const subtract = (a: number, b: number) => op(a, b, -1)
         """
+      And step "implement.building" writes "src/acceptance.test.ts" with:
+        """
+        it("[AC-1] holds", () => {})
+        """
       And step "implement.health.check" changes nothing
       And step "implement.closing" runs its script
       And judge step "implement.coverage" answers:
@@ -717,6 +737,10 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
         export const add = (a: number, b: number) => op(a, b, 1)
         export const subtract = (a: number, b: number) => op(a, b, -1)
         """
+      And step "implement.building" writes "src/acceptance.test.ts" with:
+        """
+        it("[AC-1] holds", () => {})
+        """
       And step "implement.health.check" changes nothing
       And step "implement.closing" runs its script
       And judge step "implement.coverage" answers:
@@ -983,6 +1007,10 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
         export const add = (a: number, b: number) => op(a, b, 1)
         export const subtract = (a: number, b: number) => op(a, b, -1)
         """
+      And step "implement.building" writes "src/acceptance.test.ts" with:
+        """
+        it("[AC-1] holds", () => {})
+        """
       And step "implement.health.check" changes nothing
       And step "implement.closing" runs its script
       And judge step "implement.coverage" answers:
@@ -1066,6 +1094,10 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
         export const add = (a: number, b: number) => op(a, b, 1)
         export const subtract = (a: number, b: number) => op(a, b, -1)
         """
+      And step "implement.building" writes "src/acceptance.test.ts" with:
+        """
+        it("[AC-1] holds", () => {})
+        """
       And step "implement.health.check" changes nothing
       And step "implement.closing" runs its script
       And judge step "implement.coverage" answers:
@@ -1212,6 +1244,10 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
         """
         [{"id":"shape","answer":"refactor-first","p":0.9}]
         """
+      And step "seam.note" writes ".gtd/REFACTOR-NOTE.md" with:
+        """
+        Seam: the existing code the strays touch.
+        """
       And step "refactor.deriving" runs its script
       And step "refactor.building" writes "src/calc.ts" with:
         """
@@ -1236,7 +1272,7 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
     Scenario: each slice's quality lap reviews from that slice's base
       When the process is driven
       Then the process rests at "refactor.build.quality.correctness.reviewing"
-      And the resting step's content contains the hash of the commit "gtd(judge): seam.judge → refactor.deriving"
+      And the resting step's content contains the hash of the commit "gtd(agent): seam.note → refactor.deriving"
       Given step "refactor.build.quality.correctness.reviewing" changes nothing
       And step "implement.building" writes "src/calc.ts" with:
         """
@@ -1244,6 +1280,10 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
         export const add = (a: number, b: number) => op(a, b, 1)
         export const subtract = (a: number, b: number) => op(a, b, -1)
         """
+      And step "implement.building" writes "src/acceptance.test.ts" with:
+        """
+        it("[AC-1] holds", () => {})
+        """
       And step "implement.health.check" changes nothing
       And step "implement.closing" runs its script
       And judge step "implement.coverage" answers:
@@ -1318,6 +1358,10 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
         """
         [{"id":"shape","answer":"refactor-first","p":0.9}]
         """
+      And step "seam.note" writes ".gtd/REFACTOR-NOTE.md" with:
+        """
+        Seam: the existing code the strays touch.
+        """
 
     Scenario: a test-file stray is dropped from the derived refactor package
       Given step "seam.check" changes nothing

package/src/workflows/feature/refactor.ts

@@ -27,6 +27,8 @@ export const REFACTOR_PACKAGE = REFACTOR
 export interface RefactorOptions {
   /** Blank counts as absent: `kept()` reports `""` while the keeping turn is pending. */
   readonly reference?: string | undefined
+  /** The refactor note `seam.note` wrote; rides the package as `## Refactor note`. */
+  readonly note?: string | undefined
 }
 
 const isCode = (path: string): boolean => path !== ".gtd" && !path.startsWith(".gtd/")
@@ -203,7 +205,7 @@ const packageLines = (
   "",
 ]
 
-// Nested under `## Review feedback`, so every heading of the collected text drops a level.
+// Nested under a `##` section (review feedback, the refactor note), so every heading drops a level.
 const demoteHeadings = (text: string): string[] => {
   const marked = markFenced(text.trimEnd())
   const lines = marked.map((m) => m.line)
@@ -230,6 +232,7 @@ interface Plan {
   readonly pattern: string
   readonly strays: readonly string[]
   readonly reference: string | undefined
+  readonly note: string | undefined
 }
 
 /** Undefined for every shape that is not a readable `refactor-first`; throws on a bad flag pattern. */
@@ -245,7 +248,8 @@ const plan = (shape: DiffShapeResult, options: RefactorOptions): Plan | undefine
       `gtd: refactorFlagPattern (${pattern}) produces a zero-length match in:\n${listPaths(zeroLength)}`,
     )
   const reference = options.reference?.trim() ? options.reference : undefined
-  return { pattern, strays, reference }
+  const note = options.note?.trim() ? options.note : undefined
+  return { pattern, strays, reference, note }
 }
 
 // The in-memory `strays`, never the package file: a hand edit of its list changes nothing.
@@ -260,11 +264,12 @@ const guardOf =
 
 /** Derive, build, check and close one refactor lap; `feedback` is the collected review text of the lap before. */
 const refactorLap = async (p: Plan, guard: Guard, feedback?: string): Promise<void> => {
-  const { pattern, strays, reference } = p
+  const { pattern, strays, reference, note } = p
   await run(
     "deriving",
     deriveScript([
       ...packageLines(strays, pattern, reference),
+      ...(note === undefined ? [] : ["## Refactor note", "", ...demoteHeadings(note), ""]),
       ...(feedback === undefined
         ? []
         : ["## Review feedback", "", ...demoteHeadings(feedback), ""]),
@@ -279,6 +284,7 @@ const refactorLap = async (p: Plan, guard: Guard, feedback?: string): Promise<vo
       pattern,
       reference,
       feedback: feedback !== undefined,
+      note: note !== undefined,
     }),
     { label: "Refactoring", model: coder(), system: t.builderSystem() },
   )

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

@@ -13,6 +13,9 @@ import {
   judgeSeam,
   naivePass,
   acceptanceFault,
+  naiveAcceptance,
+  requireAcceptance,
+  requireAcceptanceKept,
   seamBuild,
   type SeamOutcome,
 } from "./seam.js"
@@ -105,6 +108,67 @@ describe("naivePass", () => {
   })
 })
 
+describe("naiveAcceptance and requireAcceptance", () => {
+  const requirements = "# R\n\n## Acceptance Criteria\n\n- AC-1: adds.\n- AC-2: subtracts.\n"
+  const file = (path: string, before: string | undefined, after: string): Change => ({
+    path,
+    status: before === undefined ? "added" : "modified",
+    before,
+    after,
+  })
+  const install = (since: Change[] = []) =>
+    installContext({
+      ...fixtureContext({}),
+      matches: globMatches,
+      read: (path: string) => (path === ".gtd/REQUIREMENTS.md" ? requirements : undefined),
+      changesSince: () => since,
+      changes: () => since,
+      refuse: (message: string) => {
+        throw new Error(message)
+      },
+    } as unknown as FlowContext)
+
+  it("takes the IDs the pass's tests name on an added line, and only those test files", () => {
+    install()
+    expect(
+      naiveAcceptance(
+        tip(
+          file("src/a.test.ts", 'it("[AC-2] old")', 'it("[AC-2] old")\nit("[AC-1] adds")'),
+          file("src/b.test.ts", undefined, 'it("helper")'),
+          file("src/calc.ts", "x", "AC-2"),
+        ),
+      ),
+    ).toEqual({ hash: "abc", tests: ["src/a.test.ts"], ids: ["AC-1"] })
+  })
+
+  it("refuses a rebuild whose tests leave out an ID, naming the naive tests to carry over", () => {
+    install([file("src/calc.test.ts", undefined, 'it("[AC-1] adds")')])
+    expect(() =>
+      requireAcceptance({ hash: "abc", tests: ["src/a.test.ts"], ids: ["AC-1", "AC-2"] }, "c0"),
+    ).toThrow(
+      /^gtd land: rebuild-acceptance: .*leave out AC-2 — .*git show abc -- 'src\/a\.test\.ts'/,
+    )
+  })
+
+  it("refuses a fix turn that itself drops a carried ID, never one that leaves it alone", () => {
+    const acceptance = { hash: "abc", tests: [], ids: ["AC-1"] }
+    install([file("src/calc.test.ts", 'it("[AC-1] adds")', 'it("adds")')])
+    expect(() => requireAcceptanceKept(acceptance)).toThrow(/drops AC-1/)
+    install([file("src/calc.ts", "a", "b")])
+    expect(() => requireAcceptanceKept(acceptance)).not.toThrow()
+  })
+
+  it("passes a rebuild whose tests name every ID, wherever they live", () => {
+    install([
+      file("tests/x.test.ts", undefined, 'it("[AC-1] adds")'),
+      file("tests/y.feature", "", "Scenario: [AC-2] subtracts"),
+    ])
+    expect(() =>
+      requireAcceptance({ hash: "abc", tests: ["src/a.test.ts"], ids: ["AC-1", "AC-2"] }, "c0"),
+    ).not.toThrow()
+  })
+})
+
 describe("acceptanceFault", () => {
   const requirements = "# R\n\n## Acceptance Criteria\n\n- AC-1: adds.\n- AC-2: subtracts.\n"
   const file = (path: string, status: Change["status"], after: string): Change => ({
@@ -231,6 +295,7 @@ describe("acceptanceFault", () => {
 
 const REVIEW = ".gtd/REVIEW.md"
 const REFACTOR = ".gtd/REFACTOR.md"
+const NOTE = ".gtd/REFACTOR-NOTE.md"
 const reviewDoc = [
   "# Review: abc1234",
   "",
@@ -267,6 +332,7 @@ const driveSeam = async (
   const files = new Map<string, string>([["src/a.ts", "a"]])
   let current = "c0"
   const effects: Record<string, () => void> = {
+    note: () => void files.set(NOTE, "Seam: a shared op"),
     deriving: () => void files.set(REFACTOR, "package"),
     closing: () => void files.delete(REFACTOR),
     "review.reviewing": () => void files.set(REVIEW, reviewDoc),
@@ -321,13 +387,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,13 +427,20 @@ 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 () => {
     const h = await driveSeam("refactor-first")
-    expect(h.outcome).toEqual({ reference: "abc", base: "after-refactor", refactored: true })
+    expect(h.outcome).toEqual({
+      reference: "abc",
+      base: "after-refactor",
+      refactored: true,
+      rebuild: { note: "Seam: a shared op", acceptance: { hash: "abc", tests: [], ids: [] } },
+    })
     expect(h.slices).toEqual(["refactor"])
+    expect(h.names.indexOf("seam.note")).toBe(h.names.indexOf("seam.judge") + 1)
+    expect(h.inside.refactor).not.toContain("seam.note")
     expect(h.inside.refactor![0]).toBe("refactor.deriving")
     expect(h.inside.refactor).toContain("refactor.build.review.closing")
     expect(h.names.some((n) => n.includes("approve"))).toBe(false)
@@ -372,7 +451,11 @@ describe("seamBuild", () => {
     const h = await driveSeam("refactor-first", change("src/a.test.ts", "modified"), {
       seamAllow: ".gtd/**",
     })
-    expect(h.outcome).toEqual({ reference: "abc", base: "c-base" })
+    expect(h.outcome).toEqual({
+      reference: "abc",
+      base: "c-base",
+      rebuild: { acceptance: { hash: "abc", tests: [], ids: [] } },
+    })
     expect(h.slices).toEqual([])
     expect(h.names).not.toContain("seam.by-hand")
     expect(h.names.some((n) => n.startsWith("refactor"))).toBe(false)
@@ -397,7 +480,11 @@ describe("seamBuild", () => {
     })
     expect(h.slices).toEqual([])
     expect(h.names).toContain("seam.by-hand")
-    expect(h.outcome).toEqual({ reference: "abc", base: "c-base" })
+    expect(h.outcome).toEqual({
+      reference: "abc",
+      base: "c-base",
+      rebuild: { acceptance: { hash: "abc", tests: [], ids: [] } },
+    })
   })
 })
 
@@ -466,6 +553,30 @@ describe("implement", () => {
     expect(bare).toBe(await building(undefined))
   })
 
+  it("a rebuild quotes the refactor note and names the naive acceptance tests to carry over", async () => {
+    const prompt = await building("abc", undefined, undefined, () =>
+      implement({
+        reference: "abc",
+        rebuild: {
+          note: "# Note\n\nSeam: a shared op",
+          acceptance: { hash: "abc", tests: ["src/a.test.ts"], ids: ["AC-1"] },
+        },
+        // The fixture's turn carries no test, so the acceptance guard refuses it after the prompt.
+      }).catch(() => undefined),
+    )
+    expect(prompt).toContain("  > Seam: a shared op")
+    expect(prompt).toContain("acceptance tests for AC-1")
+    expect(prompt).toContain("git show abc -- 'src/a.test.ts'")
+  })
+
+  it("a rebuild whose naive tests named no ID asks to carry nothing over", async () => {
+    const prompt = await building("abc", undefined, undefined, () =>
+      implement({ reference: "abc", rebuild: { acceptance: { hash: "abc", tests: [], ids: [] } } }),
+    )
+    expect(prompt).not.toContain("Carry over")
+    expect(prompt).not.toContain("refactor note")
+  })
+
   it("names the reference with a git show line", async () => {
     expect(await building("abc")).toContain("git show abc")
   })