@pmelab/gtd 27.0.0 → 27.2.0

package/src/workflows/cleanup/cleanup.feature

@@ -0,0 +1,323 @@
+Feature: cleanup removes a default-on release flag and keeps its flag-on path
+
+  `gtd --workflow cleanup --var flag=<name>` has an agent delete the registry
+  entry and the off path; checks refuse a surviving entry or env-var reference,
+  then the shared health loop and review run; the same checks re-run after every later agent turn. A review note ends the process.
+
+  Background:
+    Given the shipped workflows, as gtd install scaffolds them
+    And a gtd config with:
+      """
+      export {
+        feature as default,
+        feature,
+        defaults,
+        envDefaults,
+        summary,
+        steering,
+        skills,
+        access,
+      } from "@pmelab/gtd/workflows/feature"
+      import { cleanup } from "@pmelab/gtd/workflows"
+      export { cleanup }
+      """
+    And an environment variable "GTD_QUALITYREVIEWS" set to ""
+    And a file "src/flags/index.ts" with:
+      """
+      export const FLAGS = [
+        { name: "alpha", owner: "a", expiry: "2027-01-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 a file "src/calc.ts" with:
+      """
+      export const on = process.env.GTD_FLAG_LIVE !== "0"
+      """
+    And the working tree is committed as "feat: registry"
+
+  Scenario: removing the entry and the off path lands, then reaches the review gate
+    Given step "cleanup.removing" writes "src/flags/index.ts" with:
+      """
+      export const FLAGS = [
+        { name: "alpha", owner: "a", expiry: "2027-01-01", kind: "release" },
+        { name: "ops1", owner: "c", expiry: "2027-03-01", kind: "ops" },
+      ] as const
+      """
+    And step "cleanup.removing" writes "src/calc.ts" with:
+      """
+      export const on = true
+      """
+    And step "build.health.check" changes nothing
+    And step "build.review.reviewing" writes ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## calc
+
+      - [ ] ./src/calc.ts#1-1
+        flag removed
+      """
+    When gtd starts workflow "cleanup" with "--var flag=live"
+    And the process is driven
+    Then the process rests at "build.review.await-review"
+    And "src/flags/index.ts" does not contain "live"
+
+  Scenario: a turn leaving the registry entry is refused
+    Given step "cleanup.removing" writes "src/calc.ts" with:
+      """
+      export const on = true
+      """
+    When gtd starts workflow "cleanup" with "--var flag=live"
+    Then driving the process is refused with "src/flags/index.ts still declares flag \"live\""
+
+  Scenario: a turn leaving the env var in a shipped source is refused naming path:line
+    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
+      """
+    When gtd starts workflow "cleanup" with "--var flag=live"
+    Then driving the process is refused with "src/calc.ts:1 still names GTD_FLAG_LIVE"
+
+  Scenario: the same env var in a test file is allowed
+    Given a file "src/calc.test.ts" with:
+      """
+      process.env.GTD_FLAG_LIVE = "0"
+      """
+    And the working tree is committed as "test: pin kill switch"
+    And 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 starts workflow "cleanup" with "--var flag=live"
+    And the process is driven
+    Then the process rests at "build.review.reviewing"
+
+  @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:
+      """
+      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
+      """
+    When gtd starts workflow "cleanup" with "--var flag=live"
+    And the process is driven
+    Then the process rests at "build.health.check"
+
+    Given a file ".gtd/FEEDBACK.md" with:
+      """
+      1 failing
+      """
+    When gtd lands
+    Then the process rests at "build.fix"
+
+    Given step "build.fix" writes "src/flags/index.ts" with:
+      """
+      export const FLAGS = [
+        { name: "alpha", owner: "a", expiry: "2027-01-01", kind: "release" },
+        { name: "live", owner: "d", expiry: "2027-04-01", kind: "release", defaultOn: true },
+      ] as const
+      """
+    Then driving the process is refused with "still declares flag \"live\""
+
+  @inmem
+  Scenario: a fix after a red suite that re-adds the env var to a shipped source is refused
+    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
+      """
+    When gtd starts workflow "cleanup" with "--var flag=live"
+    And the process is driven
+    Then the process rests at "build.health.check"
+
+    Given a file ".gtd/FEEDBACK.md" with:
+      """
+      1 failing
+      """
+    When gtd lands
+    Then the process rests at "build.fix"
+
+    Given step "build.fix" writes "src/calc.ts" with:
+      """
+      export const on = process.env.GTD_FLAG_LIVE !== "0"
+      """
+    Then driving the process is refused with "src/calc.ts:1 still names GTD_FLAG_LIVE"
+
+  @inmem
+  Scenario: a fix after a red suite that edits another file only 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
+      """
+    When gtd starts workflow "cleanup" with "--var flag=live"
+    And the process is driven
+    Then the process rests at "build.health.check"
+
+    Given a file ".gtd/FEEDBACK.md" with:
+      """
+      1 failing
+      """
+    When gtd lands
+    Then the process rests at "build.fix"
+
+    Given step "build.fix" writes "src/other.ts" with:
+      """
+      export const other = 1
+      """
+    And step "build.health.check" changes nothing
+    When the process is driven
+    Then the process rests at "build.review.reviewing"
+
+  @inmem
+  Scenario: a risk-fix turn after the review that restores the registry entry is refused
+    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
+    And step "build.review.reviewing" writes ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## calc
+
+      - [ ] ./src/calc.ts#1-1
+        Risk: leaks
+      """
+    And step "build.review.fix.risks.fixing" writes "src/flags/index.ts" with:
+      """
+      export const FLAGS = [
+        { name: "alpha", owner: "a", expiry: "2027-01-01", kind: "release" },
+        { name: "live", owner: "d", expiry: "2027-04-01", kind: "release", defaultOn: true },
+      ] as const
+      """
+    When gtd starts workflow "cleanup" with "--var flag=live"
+    Then driving the process is refused with "still declares flag \"live\""
+
+  @inmem
+  Scenario: the human's review sign-off may restore the registry entry
+    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
+    And step "build.review.reviewing" writes ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## calc
+
+      - [ ] ./src/calc.ts#1-1
+        fine
+      """
+    When gtd starts workflow "cleanup" with "--var flag=live"
+    And the process is driven
+    Then the process rests at "build.review.await-review"
+
+    Given a file "src/flags/index.ts" with:
+      """
+      export const FLAGS = [
+        { name: "alpha", owner: "a", expiry: "2027-01-01", kind: "release" },
+        { name: "live", owner: "d", expiry: "2027-04-01", kind: "release", defaultOn: true },
+      ] as const
+      """
+    When gtd lands
+    Then the process rests at "build.health.check"
+
+  Scenario: a review note ends the process leaving the review for fix
+    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
+    And step "build.review.reviewing" writes ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## calc
+
+      - [ ] ./src/calc.ts#1-1
+        flag removed
+      """
+    When gtd starts workflow "cleanup" with "--var flag=live"
+    And the process is driven
+    Then the process rests at "build.review.await-review"
+
+    Given a file ".gtd/REVIEW.md" with:
+      """
+      # Review: abc1234
+
+      <!-- base: 0000000 -->
+
+      ## calc
+
+      - [ ] ./src/calc.ts#1-1
+        flag removed — also drop the constant
+      """
+    And step "build.review.handing-off" runs its script
+    When gtd lands
+    And the process is driven
+    Then the process rests at "idle"
+    And ".gtd/REVIEW.md" contains "also drop the constant"
+    And ".gtd/REVIEW.orig.md" contains "flag removed"
+
+  Scenario: a default-off flag is refused at start
+    Then starting workflow "cleanup" with "--var flag=alpha" is refused with "flag \"alpha\" is not default-on — roll it out first"
+
+  Scenario: an unknown flag is refused at start
+    Then starting workflow "cleanup" with "--var flag=nope" is refused with "no flag \"nope\" in src/flags/index.ts"
+
+  Scenario: a non-release flag is refused at start
+    Then starting workflow "cleanup" with "--var flag=ops1" is refused with "flag \"ops1\" is ops, not release"

package/src/workflows/cleanup/cleanup.test.ts

@@ -0,0 +1,272 @@
+import { describe, expect, it } from "vitest"
+import { CONFIG_SCAFFOLD } from "../../install/index.js"
+import { testRepo, type TestRepo } from "../../testkit/index.js"
+import { reviewDoc } from "../shared/config.fixture.js"
+
+type Actors = NonNullable<Parameters<TestRepo["drive"]>[0]>
+
+const CONFIG = `${CONFIG_SCAFFOLD}export { cleanup } from "@pmelab/gtd/workflows"\n`
+
+const REGISTRY = `export const FLAGS = [
+  { name: "alpha", owner: "a", expiry: "2027-01-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
+`
+const WITHOUT_LIVE = REGISTRY.replace(/  \{ name: "live".*\n/, "")
+const SOURCE = "export const on = process.env.GTD_FLAG_LIVE !== '0'\n"
+
+const repoWith = () =>
+  testRepo({
+    workflow: CONFIG,
+    env: { GTD_QUALITYREVIEWS: "" },
+    files: { "src/flags/index.ts": REGISTRY, "src/a.ts": SOURCE },
+  })
+
+describe("the cleanup workflow", () => {
+  it("lands a removal and reaches the review", async () => {
+    const repo = repoWith()
+    await repo.start("cleanup", "--var", "flag=live")
+    const rest = await repo.drive({
+      "cleanup.removing": (beat, r) => {
+        expect(beat.content).toContain("live")
+        r.write("src/flags/index.ts", WITHOUT_LIVE)
+        r.write("src/a.ts", "export const on = true\n")
+      },
+      "build.health.check": () => undefined,
+    })
+    expect(rest).toMatchObject({ state: "build.review.reviewing", actor: "agent" })
+  })
+
+  it("refuses to start over a pending hand-off", async () => {
+    const repo = testRepo({
+      workflow: CONFIG,
+      files: {
+        "src/flags/index.ts": REGISTRY,
+        ".gtd/REVIEW.md": "# Review: abc1234\n",
+        ".gtd/REVIEW.orig.md": "# Review: abc1234\n",
+      },
+    })
+    await expect(repo.start("cleanup", "--var", "flag=live")).rejects.toThrow(
+      ".gtd/REVIEW.orig.md is a pending hand-off",
+    )
+  })
+
+  it("refuses a turn that leaves the registry entry", async () => {
+    const repo = repoWith()
+    await repo.start("cleanup", "--var", "flag=live")
+    await expect(
+      repo.drive({ "cleanup.removing": (_, r) => r.write("src/a.ts", "export const on = true\n") }),
+    ).rejects.toThrow('gtd land: cleanup: src/flags/index.ts still declares flag "live"')
+  })
+
+  it("refuses a turn leaving the env var in a shipped source, naming path:line", async () => {
+    const repo = repoWith()
+    await repo.start("cleanup", "--var", "flag=live")
+    await expect(
+      repo.drive({ "cleanup.removing": (_, r) => r.write("src/flags/index.ts", WITHOUT_LIVE) }),
+    ).rejects.toThrow("gtd land: cleanup: src/a.ts:1 still names GTD_FLAG_LIVE")
+  })
+
+  it.each([
+    [[], "gtd: cleanup needs --var flag=<name>"],
+    [["--var", "flag=nope"], 'gtd: cleanup: no flag "nope" in src/flags/index.ts'],
+    [["--var", "flag=ops1"], 'gtd: cleanup: flag "ops1" is ops, not release'],
+    [["--var", "flag=alpha"], 'gtd: cleanup: flag "alpha" is not default-on — roll it out first'],
+  ])("refuses %j at start", async (args, message) => {
+    await expect(repoWith().start("cleanup", ...args)).rejects.toThrow(message)
+  })
+})
+
+describe("the cleanup guard over every later agent turn", () => {
+  const FEEDBACK = ".gtd/FEEDBACK.md"
+  const CLEAN = "export const on = true\n"
+  const NAMED = "export const on = process.env.GTD_FLAG_LIVE\n"
+  const REMOVED: Actors = {
+    "cleanup.removing": (_, r) => {
+      r.write("src/flags/index.ts", WITHOUT_LIVE)
+      r.write("src/a.ts", CLEAN)
+    },
+    "build.health.check": () => undefined,
+  }
+
+  // Without the shipped access rules, which would refuse a source write from a read-only turn first: the guard is the second line.
+  const NO_ACCESS = CONFIG.replace("  access,\n", "")
+
+  const guarded = (lenses = "", workflow = CONFIG) =>
+    testRepo({
+      workflow,
+      env: { GTD_QUALITYREVIEWS: lenses },
+      files: {
+        "src/flags/index.ts": REGISTRY,
+        "src/a.ts": SOURCE,
+        "src/calc.ts": "export const add = 1\n",
+      },
+    })
+
+  const redOnce = (): Actors => {
+    let runs = 0
+    return {
+      "build.health.check": (_, r) => {
+        if (runs++ === 0) r.write(FEEDBACK, "1 failing\n")
+      },
+    }
+  }
+
+  const driven = async (repo: ReturnType<typeof guarded>, actors: Actors) => {
+    await repo.start("cleanup", "--var", "flag=live")
+    return repo.drive({ ...REMOVED, ...actors })
+  }
+
+  it("refuses a build.fix that restores the registry entry", async () => {
+    await expect(
+      driven(guarded(), {
+        ...redOnce(),
+        "build.fix": (_, r) => r.write("src/flags/index.ts", REGISTRY),
+      }),
+    ).rejects.toThrow('src/flags/index.ts still declares flag "live"')
+  })
+
+  it("refuses a build.fix that adds the env var to a source, naming path:line", async () => {
+    await expect(
+      driven(guarded(), { ...redOnce(), "build.fix": (_, r) => r.write("src/b.ts", NAMED) }),
+    ).rejects.toThrow("gtd land: cleanup: src/b.ts:1 still names GTD_FLAG_LIVE")
+  })
+
+  it("lets a build.fix add the env var to a test file", async () => {
+    const rest = await driven(guarded(), {
+      ...redOnce(),
+      "build.fix": (_, r) => r.write("src/b.test.ts", NAMED),
+    })
+    expect(rest.state).toBe("build.review.reviewing")
+  })
+
+  it("lets a build.fix touching only another file reach the review", async () => {
+    const rest = await driven(guarded(), {
+      ...redOnce(),
+      "build.fix": (_, r) => r.write("src/other.ts", CLEAN),
+    })
+    expect(rest).toMatchObject({ state: "build.review.reviewing", actor: "agent" })
+  })
+
+  it("refuses the human's build.health.stop landing that restores the registry entry", async () => {
+    let stopped = false
+    let runs = 0
+    const repo = guarded()
+    await repo.start("cleanup", "--var", "flag=live")
+    await expect(
+      repo.drive({
+        ...REMOVED,
+        "build.health.check": (_, r) => {
+          if (!stopped) r.write(FEEDBACK, `failing ${runs++}\n`)
+        },
+        "build.health.describe": () => undefined,
+        "build.health.judge": () => '[{"id":"verdict","answer":"progress","p":0.9}]',
+        "build.fix": (_, r) => r.write("src/other.ts", `export const n = ${runs}\n`),
+        "build.health.stop": (_, r) => {
+          stopped = true
+          r.write("src/flags/index.ts", REGISTRY)
+        },
+      }),
+    ).rejects.toThrow('still declares flag "live"')
+  })
+
+  it("refuses an escalation describe turn that re-adds the env var", async () => {
+    let runs = 0
+    await expect(
+      driven(guarded("", NO_ACCESS), {
+        "build.health.check": (_, r) => r.write(FEEDBACK, `failing ${runs++}\n`),
+        "build.health.judge": () => '[{"id":"verdict","answer":"progress","p":0.9}]',
+        "build.fix": (_, r) => r.write("src/other.ts", `export const n = ${runs}\n`),
+        "build.health.describe": (_, r) => r.write("src/b.ts", NAMED),
+      }),
+    ).rejects.toThrow("src/b.ts:1 still names GTD_FLAG_LIVE")
+  })
+
+  it("refuses the first fix after escalating quality findings that re-adds the env var", async () => {
+    await expect(
+      driven(guarded("correctness", NO_ACCESS), {
+        "build.quality.correctness.reviewing": (_, r) =>
+          r.write(".gtd/QUALITY.md", "- a finding\n"),
+        "build.fix.quality.fixing": () => undefined,
+        "build.health.describe": () => undefined,
+        "build.health.stop": () => undefined,
+        "build.fix": (_, r) => r.write("src/b.ts", NAMED),
+      }),
+    ).rejects.toThrow("src/b.ts:1 still names GTD_FLAG_LIVE")
+  })
+
+  it("refuses a quality lens turn that re-adds the env var", async () => {
+    await expect(
+      driven(guarded("correctness", NO_ACCESS), {
+        "build.quality.correctness.reviewing": (_, r) => r.write("src/b.ts", NAMED),
+      }),
+    ).rejects.toThrow("src/b.ts:1 still names GTD_FLAG_LIVE")
+  })
+
+  it("refuses a quality fix turn that restores the registry entry", async () => {
+    await expect(
+      driven(guarded("correctness"), {
+        "build.quality.correctness.reviewing": (_, r) =>
+          r.write(".gtd/QUALITY.md", "- a finding\n"),
+        "build.fix.quality.fixing": (_, r) => r.write("src/flags/index.ts", REGISTRY),
+      }),
+    ).rejects.toThrow('still declares flag "live"')
+  })
+
+  it("refuses a risk fix turn that restores the registry entry", async () => {
+    await expect(
+      driven(guarded(), {
+        "build.review.reviewing": (_, r) => r.write(".gtd/REVIEW.md", reviewDoc("Risk: leaks")),
+        "build.review.fix.risks.fixing": (_, r) => r.write("src/flags/index.ts", REGISTRY),
+      }),
+    ).rejects.toThrow('still declares flag "live"')
+  })
+
+  it("refuses a review turn that re-adds the env var", async () => {
+    await expect(
+      driven(guarded("", NO_ACCESS), {
+        "build.review.reviewing": (_, r) => {
+          r.write(".gtd/REVIEW.md", reviewDoc("fine"))
+          r.write("src/b.ts", NAMED)
+        },
+      }),
+    ).rejects.toThrow("src/b.ts:1 still names GTD_FLAG_LIVE")
+  })
+
+  it("leaves the human's review sign-off unguarded", async () => {
+    const repo = guarded()
+    await repo.start("cleanup", "--var", "flag=live")
+    const rest = await repo.drive({
+      ...REMOVED,
+      "build.review.reviewing": (_, r) => r.write(".gtd/REVIEW.md", reviewDoc("fine")),
+    })
+    expect(rest.state).toBe("build.review.await-review")
+    repo.write("src/flags/index.ts", REGISTRY)
+    await repo.land()
+    const done = await repo.drive({ "build.review.closing": () => undefined })
+    expect(done.state).not.toBe("build.review.await-review")
+  })
+
+  it("does not blame a later fix turn for the entry the human restored at sign-off", async () => {
+    const repo = guarded()
+    await repo.start("cleanup", "--var", "flag=live")
+    let runs = 0
+    const check: Actors = {
+      "build.health.check": (_, r) => {
+        if (runs++ === 1) r.write(FEEDBACK, "1 failing\n")
+      },
+    }
+    const rest = await repo.drive({
+      ...REMOVED,
+      ...check,
+      "build.review.reviewing": (_, r) => r.write(".gtd/REVIEW.md", reviewDoc("fine")),
+    })
+    expect(rest.state).toBe("build.review.await-review")
+    repo.write("src/flags/index.ts", REGISTRY)
+    repo.write("src/hand.ts", CLEAN)
+    await repo.land()
+    await repo.drive({ ...check, "build.fix": (_, r) => r.write("src/other.ts", CLEAN) })
+    expect(repo.subjects()).toContain("gtd(agent): build.fix → build.health.check")
+  })
+})

package/src/workflows/cleanup/cleanup.ts

@@ -0,0 +1,52 @@
+import { agent, changes, glob, read, refuse, scope, start, vars } from "../../flows/index.js"
+import { flagShipped } from "../shared/options.js"
+import { flagReferences, registryEntry, requireFlag } from "../shared/registry.js"
+import { coder } from "../shared/steps.js"
+import { handOffTail, refusePendingHandOff } from "../shared/tail.js"
+
+const removingPrompt = (name: string, registry: string): string =>
+  `Clean up the release flag "${name}", which is default-on: delete its entry in ${registry}, and remove every \`GTD_FLAG_${name.toUpperCase()}\` check from the shipped sources. Keep the flag-on path; delete code only the off path reached, including tests that pin the off path.`
+
+export const cleanupFlow = async (): Promise<void> => {
+  const registry = vars.flagRegistry ?? ""
+  const name = vars.flag ?? ""
+  // Before the turn, never after: replay re-runs every pre-turn check.
+  refusePendingHandOff()
+  requireFlag("cleanup", registry, name, true)
+  // After `removing` both checks are per-turn: only a turn that touched the registry or a source is refused, so the human's unguarded sign-off edits are never blamed on a later agent turn.
+  let scanned = false
+  const guard = (): void => {
+    const turn = scanned ? changes() : undefined
+    if (
+      (turn === undefined || turn.some((c) => c.path === registry)) &&
+      registryEntry(read(registry) ?? "", name) !== undefined
+    ) {
+      refuse(`gtd land: cleanup: ${registry} still declares flag "${name}"`)
+    }
+    const paths =
+      turn === undefined
+        ? [...glob("src/**/*.ts"), ...glob("src/**/*.tsx")]
+        : turn
+            .filter((c) => c.status !== "deleted")
+            .map((c) => c.path)
+            .filter((path) => path.startsWith("src/") && /\.tsx?$/.test(path))
+    const hits = flagReferences(
+      paths.map((path) => ({ path, text: read(path) ?? "" })),
+      name,
+    )
+    if (hits.length > 0) {
+      refuse(`gtd land: cleanup: ${hits.join(", ")} still names GTD_FLAG_${name.toUpperCase()}`)
+    }
+  }
+  await scope("cleanup", async () => {
+    await agent("removing", removingPrompt(name, registry), {
+      label: `Removing ${name}`,
+      model: coder(),
+    })
+    guard()
+    scanned = true
+  })
+  await handOffTail(false, start(), guard)
+}
+
+export const cleanup = flagShipped(cleanupFlow)

package/src/workflows/cleanup/index.ts

@@ -0,0 +1,6 @@
+import { cleanup } from "./cleanup.js"
+
+export { cleanup, cleanupFlow } from "./cleanup.js"
+export * from "../shared/reserved.js"
+
+export default cleanup

package/src/workflows/index.ts

@@ -5,7 +5,7 @@ import { feature } from "./feature/feature.js"
 
 export { threads, type ThreadInfo } from "../flows/index.js"
 export * from "./shared/reserved.js"
-export { ShippedOptions } from "./shared/options.js"
+export { FlagOptions, ShippedOptions } from "./shared/options.js"
 export { agentWithSkills } from "./shared/text.js"
 export * from "./shared/steps.js"
 export * from "./shared/health.js"
@@ -26,6 +26,8 @@ export { buildTail, type ReviewOutcome } from "./feature/review.js"
 export * from "./feature/feature.js"
 export { base, review, reviewFlow } from "./review/review.js"
 export { fix, fixFlow, fixReviewNotes } from "./fix/fix.js"
+export { rollout, rolloutFlow } from "./rollout/rollout.js"
+export { cleanup, cleanupFlow } from "./cleanup/cleanup.js"
 
 export default feature
 

package/src/workflows/rollout/index.ts

@@ -0,0 +1,6 @@
+import { rollout } from "./rollout.js"
+
+export { rollout, rolloutFlow } from "./rollout.js"
+export * from "../shared/reserved.js"
+
+export default rollout