@pmelab/gtd 27.8.0 → 28.0.0

package/src/replay/Trailers.test.ts

@@ -115,6 +115,17 @@ describe("the commit-message codec", () => {
     expect(parsed.version).toBe("1.2.3")
   })
 
+  it("reads a Gtd-Version carrying control bytes as unknown, and keeps spaces and parens", () => {
+    const withVersion = (value: string) =>
+      formatCommitMessage({ actor: "a", to: "b" }).replace(
+        "Gtd-Format: 1",
+        `Gtd-Version: ${value}\nGtd-Format: 1`,
+      )
+    expect(parseCommitMessage(withVersion("1.0\u001b]0;x\u0007")).version).toBeUndefined()
+    expect(parseCommitMessage(withVersion("1.0\u009b")).version).toBeUndefined()
+    expect(parseCommitMessage(withVersion("0.0.1 (dev)")).version).toBe("0.0.1 (dev)")
+  })
+
   it("omits Gtd-Branch and Gtd-Version when unset, and reads them as undefined", () => {
     const message = formatCommitMessage({ actor: "agent", to: "idle" })
     expect(message).not.toContain("Gtd-Branch")

package/src/replay/Trailers.ts

@@ -196,7 +196,9 @@ const TRAILER_READERS: Readonly<Record<string, (value: string, into: Trailers) =
     if (value !== "") into.branch ??= value
   },
   "Gtd-Version": (value, into) => {
-    if (value !== "") into.version ??= value
+    // Untrusted (fetched history): control bytes would reach the terminal; a rejected value reads as unknown.
+    // eslint-disable-next-line no-control-regex
+    if (value !== "" && !/[\u0000-\u001f\u007f-\u009f]/.test(value)) into.version ??= value
   },
   "Gtd-Kept": (value, into) => {
     if (HASH_RE.test(value)) into.kept ??= value

package/src/replay/index.ts

@@ -12,4 +12,4 @@ export {
 export { accessShapeFault, foldAccess } from "./Access.js"
 export { formatFault } from "./Format.js"
 export { refNameFault } from "./RefName.js"
-export { sliceRanges, type SliceRange } from "./Slices.js"
+export { sliceRanges } from "./Slices.js"

package/src/wire/Slices.ts

@@ -0,0 +1,25 @@
+import { WIRE_SCHEMA } from "./constants.js"
+
+export interface SliceEntry {
+  readonly name: string
+  /** Full hash, exclusive: git's base..tip. */
+  readonly base: string
+  /** Full hash, inclusive; HEAD's hash for the open slice. */
+  readonly tip: string
+  /** false only for the last slice of an underway process. */
+  readonly closed: boolean
+}
+
+export interface SlicesDocument {
+  readonly schema: number
+  readonly slices: readonly SliceEntry[]
+}
+
+/** The ONLY place `gtd slices --json`'s shape is built; copies exactly the four fields, in order. */
+export const slicesDocument = (slices: readonly SliceEntry[]): SlicesDocument => ({
+  schema: WIRE_SCHEMA,
+  slices: slices.map(({ name, base, tip, closed }) => ({ name, base, tip, closed })),
+})
+
+export const renderSlicesJson = (document: SlicesDocument): string =>
+  JSON.stringify(document) + "\n"

package/src/wire/WireSchema.test.ts

@@ -9,6 +9,8 @@ import {
   landFields,
   renderBeatJson,
   renderLandJson,
+  renderSlicesJson,
+  slicesDocument,
   statusOf,
   WIRE_SCHEMA,
   type BeatKind,
@@ -116,6 +118,9 @@ const documents: Readonly<Record<string, string>> = {
     }),
   ),
   "judge.json": JUDGE,
+  "slices.json": renderSlicesJson(
+    slicesDocument([{ name: "build", base: "a".repeat(40), tip: "b".repeat(40), closed: true }]),
+  ),
 }
 
 describe(`wire schema ${WIRE_SCHEMA}`, () => {
@@ -139,6 +144,19 @@ describe(`wire schema ${WIRE_SCHEMA}`, () => {
     }
   })
 
+  describe("slicesDocument", () => {
+    it("stamps WIRE_SCHEMA and drops any field beyond the four", () => {
+      const doc = slicesDocument([
+        { name: "n", base: "b", tip: "t", closed: false, extra: 1 } as never,
+      ])
+      expect(doc).toEqual({
+        schema: WIRE_SCHEMA,
+        slices: [{ name: "n", base: "b", tip: "t", closed: false }],
+      })
+      expect(Object.keys(doc.slices[0]!)).toEqual(["name", "base", "tip", "closed"])
+    })
+  })
+
   describe("the shape check", () => {
     const land = JSON.parse(documents["land.json"]!) as Record<string, unknown>
     const { subject, ...rest } = land

package/src/wire/golden/1/slices.json

@@ -0,0 +1,11 @@
+{
+  "schema": 1,
+  "slices": [
+    {
+      "name": "build",
+      "base": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      "tip": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+      "closed": true
+    }
+  ]
+}

package/src/wire/index.ts

@@ -10,3 +10,4 @@ export * from "./Judge.js"
 export { selectPath } from "./Select.js"
 export { resolveSession } from "./Sessions.js"
 export { globMatches } from "./Glob.js"
+export * from "./Slices.js"

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