@pmelab/gtd 27.9.0 → 28.1.0

package/src/flows/runtime.ts

@@ -490,17 +490,36 @@ export const openQuestions = (text: string): readonly OpenQuestion[] => ctx().op
 /** A workflow's one flow. */
 export type Flow = () => Promise<void>
 
+/** The slice `gtd summary --slice` writes the closing message for. */
+export interface SummarySlice {
+  readonly name: string
+  /** Exclusive, as in git's `base..tip`. */
+  readonly base: string
+  readonly tip: string
+  /** 1-based stack position: `index === count` is the last slice. */
+  readonly index: number
+  readonly count: number
+}
+
 export interface SummaryContext {
+  /** Whole process, even under a slice. */
   readonly entryCommit: string
+  /** The slice's `base` under `--slice`. */
   readonly processBase: string
+  /** The slice's `tip` under `--slice`. */
   readonly processTip: string
+  /** The slice's own under `--slice`. */
   readonly humanCommits: readonly { readonly hash: string; readonly state: string }[]
+  /** The slice's own under `--slice`. */
   readonly processCost: number
+  /** The slice's own under `--slice`. */
   readonly processCostByModel: readonly { readonly model: string; readonly cost: number }[]
-  /** Every `Gtd-Mark` of the process's commits, oldest first. */
+  /** Every `Gtd-Mark` of the process's commits, oldest first — whole process, even under a slice. */
   readonly marks: readonly Mark[]
   readonly vars: Readonly<Record<string, string>>
   readonly env: Readonly<Record<string, string>>
+  /** Present only under `gtd summary --slice`; the key is absent, not undefined, otherwise. */
+  readonly slice?: SummarySlice
 }
 
 /** `gtd summary`'s prompt — a workflow module's optional `summary` export. */

package/src/install/ConfigScaffold.ts

@@ -3,7 +3,10 @@
 export const CONFIG_SCAFFOLD = `// The workflows gtd runs here: gtd's shipped feature, review and fix.
 // Every exported function is startable with \`gtd --workflow <name>\`; the
 // default export is what a change in the tree starts. Each workflow brings
-// its own doors: \`gtd door review [base]\` and \`gtd door fix\`.
+// its own doors: \`gtd door review [base]\` and \`gtd door fix\`. Export \`rollout\`
+// from \`@pmelab/gtd/workflows/rollout\` and \`cleanup\` from
+// \`@pmelab/gtd/workflows/cleanup\` to add \`gtd door rollout <flag>\` and
+// \`gtd door cleanup <flag>\`.
 export {
   feature as default,
   feature,

package/src/install/Install.test.ts

@@ -10,6 +10,7 @@ import { resolve } from "node:path"
 import { createRequire } from "node:module"
 import { describe, expect, it } from "vitest"
 import { EDIT_COMMAND, DOOR_COMMAND, MINIMAL_DRIVER, renderBriefing } from "./Install.js"
+import { CONFIG_SCAFFOLD } from "./index.js"
 
 const SUITE_PATHS = ["gtd-build", "gtd-edit", "gtd-door"]
 const SUPERSEDED_PATHS = ["gtd-fix", "gtd-review"]
@@ -424,3 +425,12 @@ describe("DOOR_COMMAND", () => {
     expect(DOOR_COMMAND).toMatch(/usage: gtd-door <name> \[args\.\.\.\]" >&2\n\s*exit 2/)
   })
 })
+
+describe("bundled door lists", () => {
+  it("the scaffold's exports stay feature, review, fix, never rollout or cleanup", () => {
+    const code = CONFIG_SCAFFOLD.split("\n")
+      .filter((l) => !l.startsWith("//"))
+      .join("\n")
+    expect(code).not.toMatch(/rollout|cleanup/)
+  })
+})

package/src/install/Install.ts

@@ -515,8 +515,11 @@ hands off to \`gtd-build\`, which halts at the blocked gate and prints it,
 rather than starting the review; \`gtd-door fix\` on a GREEN suite is a no-op
 straight back to \`idle\` — the exec'd \`gtd-build\` exits immediately on it.
 \`gtd doors\` lists the doors a repository offers (those of the workflows its
-config exports — the bundled \`fix\` and \`review [base]\` — plus any it
-declares). Refuses with
+config exports — the bundled \`fix\` and \`review [base]\`, plus the opt-in
+\`rollout <flag>\` (turn a release flag default-on) and \`cleanup <flag>\`
+(remove it), which a config adds by exporting \`rollout\` from
+\`@pmelab/gtd/workflows/rollout\` and \`cleanup\` from
+\`@pmelab/gtd/workflows/cleanup\` — plus any it declares). Refuses with
 \`usage: gtd-door <name> [args...]\` on stderr and exit \`2\` when the name is
 missing — nothing was even attempted. Default path: \`~/.local/bin/gtd-door\`.
 

package/src/workflow/load.test.ts

@@ -651,15 +651,92 @@ describe("ConfigService", () => {
       expect((await getConfig()).workflowNamed("review")?.def.base?.("review", {})).toBe("develop")
     })
 
-    it("a door two workflows build is a config error until the doors export settles it", async () => {
-      const both = `export { feature as default, fix, fix as fix2 } from "@pmelab/gtd/workflows"`
+    it("a door several workflows build gets no door when none is exported under its name, until the doors export declares it", async () => {
+      const both = `export { feature as default, fix as fix2, fix as fix3 } from "@pmelab/gtd/workflows"`
       writeFileSync(join(projectDir, "gtd.config.ts"), `${both}\n`)
-      await expect(getConfig()).rejects.toThrow(/door "fix" is built by workflows "fix" and "fix2"/)
+      expect((await getConfig()).doors.get("fix")).toBeUndefined()
       writeFileSync(
         join(projectDir, "gtd.config.ts"),
-        `${both}\nexport const doors = { fix: { workflow: "fix2" } }\n`,
+        `${both}\nexport const doors = { fix: { workflow: "fix3" } }\n`,
       )
-      expect((await getConfig()).doors.get("fix")?.workflow).toBe("fix2")
+      expect((await getConfig()).doors.get("fix")?.workflow).toBe("fix3")
+    })
+
+    it("a door clash warns once at doors.<name>, builders sorted", async () => {
+      writeFileSync(
+        join(projectDir, "gtd.config.ts"),
+        `export { feature as default, fix as fix3, fix as fix4, fix as fix2 } from "@pmelab/gtd/workflows"\n`,
+      )
+      const cfg = await getConfig()
+      const clash = cfg.warnings.filter((w) => w.path[0] === "doors")
+      expect(clash).toEqual([
+        {
+          severity: "warning",
+          path: ["doors", "fix"],
+          origin: join(projectDir, "gtd.config.ts"),
+          message: `door "fix" is built by workflows "fix2", "fix3" and "fix4" and none is exported under that name — declare it in the "doors" export`,
+        },
+      ])
+    })
+
+    it("no clash warning when an export is named after the door, one workflow builds it, or doors declares it", async () => {
+      const both = `export { feature as default, fix as fix2, fix as fix3 } from "@pmelab/gtd/workflows"`
+      for (const body of [
+        `export { feature as default, fix as fix2, fix } from "@pmelab/gtd/workflows"\n`,
+        `export { feature as default, fix } from "@pmelab/gtd/workflows"\n`,
+        `${both}\nexport const doors = { fix: { workflow: "fix3" } }\n`,
+      ]) {
+        writeFileSync(join(projectDir, "gtd.config.ts"), body)
+        expect((await getConfig()).warnings.filter((w) => w.path[0] === "doors")).toEqual([])
+      }
+    })
+
+    it("door ownership does not depend on export order", async () => {
+      writeFileSync(
+        join(projectDir, "gtd.config.ts"),
+        `export { feature as default, fix as fix2, fix } from "@pmelab/gtd/workflows"\n`,
+      )
+      expect((await getConfig()).doors.get("fix")?.workflow).toBe("fix")
+    })
+
+    it("rollout and a second instance of it load, door rollout running workflow rollout whichever export comes first", async () => {
+      for (const body of [
+        `export { rollout } from "@pmelab/gtd/workflows"\nimport { rollout } from "@pmelab/gtd/workflows"\nexport const elsewhere = rollout({ flagRegistry: "x.ts" })`,
+        `import { rollout } from "@pmelab/gtd/workflows"\nexport const elsewhere = rollout({ flagRegistry: "x.ts" })\nexport { rollout }`,
+      ]) {
+        writeFileSync(
+          join(projectDir, "gtd.config.ts"),
+          `export { feature as default } from "@pmelab/gtd/workflows"\n${body}\n`,
+        )
+        expect((await getConfig()).doors.get("rollout")?.workflow).toBe("rollout")
+      }
+    })
+
+    it("shipped rollout and cleanup list their doors beside fix and review", async () => {
+      writeFileSync(
+        join(projectDir, "gtd.config.ts"),
+        `export { feature as default, fix, review, rollout, cleanup } from "@pmelab/gtd/workflows"\n`,
+      )
+      const { doors } = await getConfig()
+      expect([...doors.keys()]).toEqual(["cleanup", "fix", "review", "rollout"])
+      expect(doors.get("rollout")?.args).toEqual([{ name: "flag" }])
+      expect(doors.get("cleanup")?.args).toEqual([{ name: "flag" }])
+    })
+
+    it("rollout and cleanup load from their own subpaths", async () => {
+      writeFileSync(
+        join(projectDir, "gtd.config.ts"),
+        [
+          `export { feature as default, fix, review } from "@pmelab/gtd/workflows"`,
+          `export { rollout } from "@pmelab/gtd/workflows/rollout"`,
+          `export { cleanup } from "@pmelab/gtd/workflows/cleanup"`,
+          ``,
+        ].join("\n"),
+      )
+      const { doors } = await getConfig()
+      expect([...doors.keys()]).toEqual(["cleanup", "fix", "review", "rollout"])
+      expect(doors.get("rollout")?.args).toEqual([{ name: "flag" }])
+      expect(doors.get("cleanup")?.args).toEqual([{ name: "flag" }])
     })
 
     it("a config's doors merge derived doors (exported workflows) with declared doors (doors export)", async () => {

package/src/workflow/load.ts

@@ -548,31 +548,43 @@ const doorsFrom = (exports: Record<string, unknown>): ReadonlyMap<string, Door>
 
 /**
  * Each exported workflow's own doors, onto the name it is exported under. The
- * `doors` export adds to them and settles a name two workflows both declare.
+ * `doors` export adds to them and declares a name several workflows clash on.
  */
 const derivedDoors = (
   catalogue: ReadonlyMap<string, LoadedWorkflow>,
   declared: ReadonlyMap<string, Door>,
-): ReadonlyMap<string, Door> => {
-  const doors = new Map<string, Door>()
+): {
+  readonly doors: ReadonlyMap<string, Door>
+  readonly clashes: ReadonlyMap<string, readonly string[]>
+} => {
+  const builders = new Map<string, Door[]>()
   for (const [workflow, loaded] of catalogue) {
     for (const [name, spec] of Object.entries(loaded.doors ?? {})) {
       const door: Door = { ...spec, workflow }
       const problem = doorProblem(name, door)
       if (problem !== undefined)
         throw new Error(`workflow "${workflow}" builds door "${name}", which ${problem}`)
-      const other = doors.get(name)
-      if (other !== undefined && !declared.has(name)) {
-        throw new Error(
-          `door "${name}" is built by workflows "${other.workflow}" and "${workflow}" — declare it in the "doors" export to choose one (a declared door replaces the derived one, so restate its args and vars)`,
-        )
-      }
-      doors.set(name, door)
+      builders.set(name, [...(builders.get(name) ?? []), door])
     }
   }
-  return new Map([...doors, ...declared])
+  const doors = new Map<string, Door>()
+  const clashes = new Map<string, readonly string[]>()
+  for (const [name, built] of builders) {
+    const owner = ownerOf(name, built)
+    if (owner !== undefined) doors.set(name, owner)
+    else if (!declared.has(name))
+      clashes.set(
+        name,
+        built.map((door) => door.workflow),
+      )
+  }
+  return { doors: new Map([...doors, ...declared]), clashes }
 }
 
+/** The export named after the door owns it, else the sole builder; a clash of several builds no door. */
+const ownerOf = (name: string, built: readonly Door[]): Door | undefined =>
+  built.find((door) => door.workflow === name) ?? (built.length === 1 ? built[0] : undefined)
+
 /** Sort the doors and check each names a startable workflow. */
 const checkDoors = (
   declared: ReadonlyMap<string, Door>,
@@ -628,16 +640,28 @@ const loadWorkflows = (module: WorkflowModule, shipped: ShippedModules): Loaded
     }),
   )
   const defaultWorkflow = built.get(value)
+  const derived =
+    rejections.length > 0
+      ? { doors: new Map<string, Door>(), clashes: new Map<string, readonly string[]>() }
+      : derivedDoors(catalogue, doorsFrom(exports))
   return {
     file,
     catalogue,
-    doors:
-      rejections.length > 0
-        ? new Map()
-        : checkDoors(derivedDoors(catalogue, doorsFrom(exports)), catalogue),
+    doors: checkDoors(derived.doors, catalogue),
     default: defaultWorkflow && { ...defaultWorkflow, name: defaultName },
     config: compileConfig(exports["config"], module.filepath),
-    diagnostics: nameRejections(rejections),
+    diagnostics: [
+      ...nameRejections(rejections),
+      ...[...derived.clashes].map(([name, builders]): Diagnostic => {
+        const names = [...builders].sort().map((b) => JSON.stringify(b))
+        return {
+          severity: "warning",
+          message: `door "${name}" is built by workflows ${names.slice(0, -1).join(", ")} and ${names.at(-1)} and none is exported under that name — declare it in the "doors" export`,
+          path: ["doors", name],
+          origin: file.origin,
+        }
+      }),
+    ],
   }
 }
 

package/src/workflows/cleanup/cleanup.feature

@@ -75,6 +75,27 @@ Feature: cleanup removes a default-on release flag and keeps its flag-on path
     And the process is driven
     Then the process rests at "build.review.reviewing"
 
+  @inmem
+  Scenario: gtd door cleanup starts the cleanup of its flag argument and reaches the review
+    Given step "cleanup.removing" writes "src/flags/index.ts" with:
+      """
+      export const FLAGS = [
+        { name: "alpha", owner: "a", expiry: "2027-01-01", kind: "release" },
+      ] as const
+      """
+    And step "cleanup.removing" writes "src/calc.ts" with:
+      """
+      export const on = true
+      """
+    And step "build.health.check" changes nothing
+    When gtd opens door "cleanup" with "live"
+    And the process is driven
+    Then the process rests at "build.review.reviewing"
+
+  @inmem
+  Scenario: gtd door cleanup with no argument is refused naming the flag
+    Then opening door "cleanup" is refused with "usage: gtd door cleanup <flag>"
+
   @inmem
   Scenario: a fix after a red suite that restores the registry entry is refused
     Given step "cleanup.removing" writes "src/flags/index.ts" with:

package/src/workflows/cleanup/cleanup.ts

@@ -49,4 +49,4 @@ export const cleanupFlow = async (): Promise<void> => {
   await handOffTail(false, start(), guard)
 }
 
-export const cleanup = flagShipped(cleanupFlow)
+export const cleanup = flagShipped(cleanupFlow, "cleanup")

package/src/workflows/index.ts

@@ -35,6 +35,7 @@ export default feature
 
 /**
  * @deprecated Empty: each shipped workflow builds its own doors, so a config
- * gets `fix` and `review [base]` by exporting `fix` and `review`.
+ * gets `fix` and `review [base]` by exporting `fix` and `review`, and
+ * `rollout <flag>` and `cleanup <flag>` by exporting `rollout` and `cleanup`.
  */
 export const doors: Doors = {}

package/src/workflows/rollout/rollout.feature

@@ -47,11 +47,16 @@ Feature: rollout turns one release flag default-on and touches nothing else
       ] as const
       """
     And step "rollout.suite.check" changes nothing
+    And step "rollout.mentions" runs its script
     When gtd starts workflow "rollout" with "--var flag=alpha"
     And the process is driven
     Then the process rests at "idle"
     And "src/flags/index.ts" contains "kind: \"release\", defaultOn: true },"
-    And the last commit subject is "gtd(check): rollout.suite.check → idle"
+    And the commit subjects end with:
+      """
+      gtd(check): rollout.suite.check → rollout.mentions
+      gtd(check): rollout.mentions → idle
+      """
 
   Scenario: a turn also changing a source file is refused naming that path
     Given step "rollout.flipping" writes "src/flags/index.ts" with:
@@ -98,11 +103,34 @@ Feature: rollout turns one release flag default-on and touches nothing else
       ] as const
       """
     And step "rollout.suite.check" changes nothing
+    And step "rollout.mentions" runs its script
     When gtd starts workflow "elsewhere" with "--var flag=gamma"
     And the process is driven
     Then the process rests at "idle"
     And "config/flags.ts" contains "defaultOn: true"
 
+  @inmem
+  Scenario: gtd door rollout starts the rollout of its flag argument
+    Given step "rollout.flipping" writes "src/flags/index.ts" with:
+      """
+      export const FLAGS = [
+        { name: "alpha", owner: "a", expiry: "2027-01-01", kind: "release", defaultOn: true },
+        { name: "beta", owner: "b", expiry: "2027-02-01", kind: "release" },
+        { name: "ops1", owner: "c", expiry: "2027-03-01", kind: "ops" },
+        { name: "live", owner: "d", expiry: "2027-04-01", kind: "release", defaultOn: true },
+      ] as const
+      """
+    And step "rollout.suite.check" changes nothing
+    And step "rollout.mentions" runs its script
+    When gtd opens door "rollout" with "alpha"
+    And the process is driven
+    Then the process rests at "idle"
+    And "src/flags/index.ts" contains "kind: \"release\", defaultOn: true },"
+
+  @inmem
+  Scenario: gtd door rollout with no argument is refused naming the flag
+    Then opening door "rollout" is refused with "usage: gtd door rollout <flag>"
+
   Scenario: a missing flag var is refused before any turn
     Then starting workflow "rollout" with "" is refused with "gtd: rollout needs --var flag=<name>"
 
@@ -209,6 +237,258 @@ Feature: rollout turns one release flag default-on and touches nothing else
       fixed by hand
       """
     And step "rollout.suite.check" from now on changes nothing
+    And step "rollout.mentions" runs its script
     When the process is driven
     Then the process rests at "idle"
-    And the last commit subject is "gtd(check): rollout.suite.check → idle"
+    And the commit subjects end with:
+      """
+      gtd(check): rollout.suite.check → rollout.mentions
+      gtd(check): rollout.mentions → idle
+      """
+
+  @inmem
+  Scenario: a stray file written at the mentions step is refused naming that path
+    Given step "rollout.flipping" writes "src/flags/index.ts" with:
+      """
+      export const FLAGS = [
+        { name: "alpha", owner: "a", expiry: "2027-01-01", kind: "release", defaultOn: true },
+        { name: "beta", owner: "b", expiry: "2027-02-01", kind: "release" },
+        { name: "ops1", owner: "c", expiry: "2027-03-01", kind: "ops" },
+        { name: "live", owner: "d", expiry: "2027-04-01", kind: "release", defaultOn: true },
+      ] as const
+      """
+    And step "rollout.suite.check" changes nothing
+    And step "rollout.mentions" runs its script
+    And step "rollout.mentions" writes "src/stray.ts" with:
+      """
+      export const x = 1
+      """
+    When gtd starts workflow "rollout" with "--var flag=alpha"
+    Then driving the process is refused with "rollout-only: src/stray.ts changed"
+
+  @inmem
+  Scenario: a second registry entry edited at the mentions step is refused
+    Given step "rollout.flipping" writes "src/flags/index.ts" with:
+      """
+      export const FLAGS = [
+        { name: "alpha", owner: "a", expiry: "2027-01-01", kind: "release", defaultOn: true },
+        { name: "beta", owner: "b", expiry: "2027-02-01", kind: "release" },
+        { name: "ops1", owner: "c", expiry: "2027-03-01", kind: "ops" },
+        { name: "live", owner: "d", expiry: "2027-04-01", kind: "release", defaultOn: true },
+      ] as const
+      """
+    And step "rollout.suite.check" changes nothing
+    And step "rollout.mentions" runs its script
+    And step "rollout.mentions" writes "src/flags/index.ts" with:
+      """
+      export const FLAGS = [
+        { name: "alpha", owner: "a", expiry: "2027-01-01", kind: "release", defaultOn: true },
+        { name: "beta", owner: "z", expiry: "2027-02-01", kind: "release" },
+        { name: "ops1", owner: "c", expiry: "2027-03-01", kind: "ops" },
+        { name: "live", owner: "d", expiry: "2027-04-01", kind: "release", defaultOn: true },
+      ] as const
+      """
+    When gtd starts workflow "rollout" with "--var flag=alpha"
+    Then driving the process is refused with "rollout-only: other edits in src/flags/index.ts"
+
+  @inmem
+  Scenario: every line naming the flag is listed, no file is edited, and gtd summary repeats the list
+    Given a file "README.md" with:
+      """
+      # calc
+
+      The alpha formatter is on under GTD_FLAG_ALPHA=1.
+      """
+    And a file "src/calc.ts" with:
+      """
+      export const help = "pass --flag_alpha to enable the alpha formatter"
+      """
+    And the working tree is committed as "docs: mention the flag"
+    And step "rollout.flipping" writes "src/flags/index.ts" with:
+      """
+      export const FLAGS = [
+        { name: "alpha", owner: "a", expiry: "2027-01-01", kind: "release", defaultOn: true },
+        { name: "beta", owner: "b", expiry: "2027-02-01", kind: "release" },
+        { name: "ops1", owner: "c", expiry: "2027-03-01", kind: "ops" },
+        { name: "live", owner: "d", expiry: "2027-04-01", kind: "release", defaultOn: true },
+      ] as const
+      """
+    And step "rollout.suite.check" changes nothing
+    And step "rollout.mentions" runs its script
+    When gtd starts workflow "rollout" with "--var flag=alpha"
+    And the process is driven
+    Then the process rests at "idle"
+    And ".gtd/FEEDBACK.md" does not exist
+    And "README.md" contains "The alpha formatter is on under GTD_FLAG_ALPHA=1."
+    And "src/calc.ts" contains "pass --flag_alpha to enable the alpha formatter"
+    And the output of gtd "summary" contains "`README.md:3`"
+    And the output of gtd "summary" contains "src/calc.ts:1"
+
+  @inmem
+  Scenario: gtd summary's grep hint excludes a factory flagRegistry
+    Given a file "config/flags.ts" with:
+      """
+      export const FLAGS = [
+        { name: "alpha", owner: "g", expiry: "2027-05-01", kind: "release" },
+      ] as const
+      """
+    And a file "NOTES.md" with:
+      """
+      alpha 1
+      alpha 2
+      alpha 3
+      alpha 4
+      alpha 5
+      alpha 6
+      alpha 7
+      alpha 8
+      alpha 9
+      alpha 10
+      alpha 11
+      alpha 12
+      alpha 13
+      alpha 14
+      alpha 15
+      alpha 16
+      alpha 17
+      alpha 18
+      alpha 19
+      alpha 20
+      alpha 21
+      alpha 22
+      alpha 23
+      alpha 24
+      alpha 25
+      alpha 26
+      alpha 27
+      alpha 28
+      alpha 29
+      alpha 30
+      alpha 31
+      alpha 32
+      alpha 33
+      alpha 34
+      alpha 35
+      alpha 36
+      alpha 37
+      alpha 38
+      alpha 39
+      alpha 40
+      alpha 41
+      alpha 42
+      alpha 43
+      alpha 44
+      alpha 45
+      alpha 46
+      alpha 47
+      alpha 48
+      alpha 49
+      alpha 50
+      alpha 51
+      alpha 52
+      alpha 53
+      alpha 54
+      alpha 55
+      """
+    And the working tree is committed as "docs: mention the flag"
+    And step "rollout.flipping" writes "config/flags.ts" with:
+      """
+      export const FLAGS = [
+        { name: "alpha", owner: "g", expiry: "2027-05-01", kind: "release", defaultOn: true },
+      ] as const
+      """
+    And step "rollout.suite.check" changes nothing
+    And step "rollout.mentions" runs its script
+    When gtd starts workflow "elsewhere" with "--var flag=alpha"
+    And the process is driven
+    Then the process rests at "idle"
+    And the output of gtd "summary" contains "':(top,exclude,literal)config/flags.ts'"
+
+  @inmem
+  Scenario: a flag named nowhere outside the registry says so in gtd summary
+    Given step "rollout.flipping" writes "src/flags/index.ts" with:
+      """
+      export const FLAGS = [
+        { name: "alpha", owner: "a", expiry: "2027-01-01", kind: "release", defaultOn: true },
+        { name: "beta", owner: "b", expiry: "2027-02-01", kind: "release" },
+        { name: "ops1", owner: "c", expiry: "2027-03-01", kind: "ops" },
+        { name: "live", owner: "d", expiry: "2027-04-01", kind: "release", defaultOn: true },
+      ] as const
+      """
+    And step "rollout.suite.check" changes nothing
+    And step "rollout.mentions" runs its script
+    When gtd starts workflow "rollout" with "--var flag=alpha"
+    And the process is driven
+    Then the process rests at "idle"
+    And ".gtd/FEEDBACK.md" does not exist
+    And the output of gtd "summary" contains "no line outside the registry names it"
+
+  @inmem
+  Scenario: the closing commit marks the total and each listed line
+    Given a file "README.md" with:
+      """
+      # calc
+
+      The alpha formatter is on under GTD_FLAG_ALPHA=1.
+      """
+    And a file "src/calc.ts" with:
+      """
+      export const help = "pass --flag_alpha to enable the alpha formatter"
+      """
+    And the working tree is committed as "docs: mention the flag"
+    And step "rollout.flipping" writes "src/flags/index.ts" with:
+      """
+      export const FLAGS = [
+        { name: "alpha", owner: "a", expiry: "2027-01-01", kind: "release", defaultOn: true },
+        { name: "beta", owner: "b", expiry: "2027-02-01", kind: "release" },
+        { name: "ops1", owner: "c", expiry: "2027-03-01", kind: "ops" },
+        { name: "live", owner: "d", expiry: "2027-04-01", kind: "release", defaultOn: true },
+      ] as const
+      """
+    And step "rollout.suite.check" changes nothing
+    And step "rollout.mentions" runs its script
+    When gtd starts workflow "rollout" with "--var flag=alpha"
+    And the process is driven
+    Then the last commit subject is "gtd(check): rollout.mentions → idle"
+    And the last commit body contains "Gtd-Mark: flag-mentions=2"
+    And the last commit body contains "Gtd-Mark: flag-mention=README.md:3"
+    And the last commit body contains "Gtd-Mark: flag-mention=src/calc.ts:1"
+
+  @inmem
+  Scenario: a finished rollout leaves no state file for the next feature start
+    Given a file "README.md" with:
+      """
+      # calc
+
+      The alpha formatter is on under GTD_FLAG_ALPHA=1.
+      """
+    And a file "src/calc.ts" with:
+      """
+      export const help = "pass --flag_alpha to enable the alpha formatter"
+      """
+    And the working tree is committed as "docs: mention the flag"
+    And step "rollout.flipping" writes "src/flags/index.ts" with:
+      """
+      export const FLAGS = [
+        { name: "alpha", owner: "a", expiry: "2027-01-01", kind: "release", defaultOn: true },
+        { name: "beta", owner: "b", expiry: "2027-02-01", kind: "release" },
+        { name: "ops1", owner: "c", expiry: "2027-03-01", kind: "ops" },
+        { name: "live", owner: "d", expiry: "2027-04-01", kind: "release", defaultOn: true },
+      ] as const
+      """
+    And step "rollout.suite.check" changes nothing
+    And step "rollout.mentions" runs its script
+    And step "unwind" changes nothing
+    And step "start-gate.check" changes nothing
+    When gtd starts workflow "rollout" with "--var flag=alpha"
+    And the process is driven
+    Then the process rests at "idle"
+    Given a file "TODO.md" with:
+      """
+      # Add subtract
+
+      subtract(a, b) returns the difference.
+      """
+    When the process is driven
+    Then the process rests at "design.triage"
+    And ".gtd/FEEDBACK.md" does not exist