@pmelab/gtd 58.1.0 → 59.0.0

package/src/workflows/feature/refactor.ts

@@ -1,368 +0,0 @@
-import {
-  changes,
-  changesSince,
-  head,
-  matches,
-  quote,
-  read,
-  refuse,
-  removeScript,
-  run,
-  scope,
-  vars,
-  type Change,
-  type DiffShapeResult,
-} from "../../flows/index.js"
-import { lensEntriesOf } from "../../workflow-kit/index.js"
-import { markFenced } from "../shared/fences.js"
-import { healthy, type Guard } from "../shared/health.js"
-import { coder, FEEDBACK, REFACTOR } from "../shared/steps.js"
-import * as t from "../shared/text.js"
-import { defaults, testFileGlobs } from "../shared/vars.js"
-import { buildTail, reUnwind, type FeedbackTarget } from "../shared/review.js"
-import { refactorCollecting } from "./steps.js"
-
-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/")
-
-export const requireWithin = (allowed: readonly string[]): void => {
-  const outside = changes()
-    .map((c) => c.path)
-    .filter((path) => isCode(path) && !allowed.includes(path))
-  if (outside.length === 0) return
-  refuse(
-    `gtd land: refactor-scope: the refactor may change only its stray paths — revert these:\n${outside.map((path) => `  - ${path}`).join("\n")}`,
-  )
-}
-
-// A fixed list, not `seamAllow`: narrowing that setting must not let a test file through.
-export const isTestFile = (path: string): boolean =>
-  testFileGlobs.some((glob) => matches(path, glob))
-
-// The bundled refactor uses `requireTestCallSitesOnly`; this stays a public export.
-export const requireNoTestFiles = (): void => {
-  const tests = changes()
-    .map((c) => c.path)
-    .filter((path) => isCode(path) && isTestFile(path))
-  if (tests.length === 0) return
-  refuse(
-    `gtd land: refactor-tests: the refactor may not change a test file — revert these:\n${tests.map((path) => `  - ${path}`).join("\n")}`,
-  )
-}
-
-// Call sites live in code: a `.feature` file or a snapshot holds only expectations.
-export const holdsCallSites = (path: string): boolean =>
-  !path.endsWith(".feature") && !path.endsWith(".snap")
-
-// `//` after a `:` (a URL) and `/*` after `*` or `/` (a glob) sit in strings, not comments.
-export const COMMENT = /(?<![*/])\/\*[\s\S]*?\*\/|(?<!:)\/\/.*$/gm
-const ASSERTION = /\b(?:expect|assert\w*)\s*[.(]/g
-const TEST_CASE = /(?<![.\w])x?(?:it|test|describe)\s*[.(]/g
-const MODIFIER =
-  /(?<![.\w])(?:it|test|describe)\.(skip|only|todo|fails|skipIf|runIf)\b|(?<![.\w])(x)(?:it|test|describe)\b/g
-
-// Modifiers count per kind, so swapping a `.skip` for an `.only` shows.
-const counts = (text: string): string => {
-  const live = text.replace(COMMENT, "")
-  const modifiers = [...live.matchAll(MODIFIER)].map((m) => m[1] ?? m[2]).sort()
-  return JSON.stringify([
-    [...live.matchAll(ASSERTION)].length,
-    [...live.matchAll(TEST_CASE)].length,
-    modifiers,
-  ])
-}
-
-const tested = (text: string): boolean => {
-  const live = text.replace(COMMENT, "")
-  return live.search(ASSERTION) >= 0 || live.search(TEST_CASE) >= 0
-}
-
-// A call-shape update keeps every live test and assertion, so the counts hold. A changed
-// expected value keeps every count — that is left to the refactor review.
-const callSitesOnly = ({ path, status, before, after }: Change): boolean =>
-  status === "modified" &&
-  holdsCallSites(path) &&
-  before !== undefined &&
-  after !== undefined &&
-  // A file with no test or assertion is fixture or helper data, never a call site to follow.
-  tested(before) &&
-  counts(before) === counts(after)
-
-/**
- * The test-file half of the refactor guard: an existing test may follow a changed call shape,
- * nothing more. Returns the test files it admitted, which the scope check then allows.
- */
-export const requireTestCallSitesOnly = (): readonly string[] => {
-  const tests = changes().filter((c) => isCode(c.path) && isTestFile(c.path))
-  const refused = tests.filter((c) => !callSitesOnly(c)).map((c) => c.path)
-  if (refused.length > 0)
-    refuse(
-      `gtd land: refactor-tests: the refactor may update an existing test file's call sites only — never add, delete, skip or comment out a test or an assertion, or touch a snapshot, a .feature file or test data; revert these:\n${refused.map((path) => `  - ${path}`).join("\n")}`,
-    )
-  return tests.map((c) => c.path)
-}
-
-const flagExpression = (pattern: string): RegExp => {
-  if (pattern.trim() === "") throw new Error("gtd: refactorFlagPattern must not be blank")
-  let expression: RegExp
-  try {
-    expression = new RegExp(pattern, "g")
-  } catch (error) {
-    throw new Error(`gtd: refactorFlagPattern is not a valid regular expression: ${String(error)}`)
-  }
-  // An empty match would count the name "" at every character.
-  if (expression.test(""))
-    throw new Error("gtd: refactorFlagPattern must not match the empty string")
-  return expression
-}
-
-// A zero-length match is never counted: a lookahead-only pattern would count every read
-// under "" and let a flag swap pass. Checked on the strays up front and again at landing.
-const countFlags = (text: string, expression: RegExp, into: Map<string, number>): boolean => {
-  let zeroLength = false
-  for (const [name] of text.matchAll(expression)) {
-    if (name === "") zeroLength = true
-    else into.set(name, (into.get(name) ?? 0) + 1)
-  }
-  return zeroLength
-}
-
-const listPaths = (paths: readonly string[]): string =>
-  paths.map((path) => `  - ${path}`).join("\n")
-
-// Counts per name, so a read moved between files passes.
-export const requireNoNewFlags = (pattern: string, since: string): void => {
-  const expression = flagExpression(pattern)
-  const before = new Map<string, number>()
-  const after = new Map<string, number>()
-  const unreadable: string[] = []
-  const zeroLength: string[] = []
-  for (const { path, status, before: was, after: now } of changesSince(since)) {
-    if (!isCode(path)) continue
-    // A side absent by status is empty; one absent otherwise could not be read.
-    const oldSide = status === "added" ? "" : was
-    const newSide = status === "deleted" ? "" : now
-    if (oldSide === undefined || newSide === undefined) {
-      unreadable.push(path)
-      continue
-    }
-    countFlags(oldSide, expression, before)
-    if (countFlags(newSide, expression, after)) zeroLength.push(path)
-  }
-  if (unreadable.length > 0)
-    refuse(`gtd land: refactor-flags: cannot compare flag reads in:\n${listPaths(unreadable)}`)
-  if (zeroLength.length > 0)
-    refuse(
-      `gtd land: refactor-flags: refactorFlagPattern (${pattern}) produced a zero-length match in:\n${listPaths(zeroLength)}`,
-    )
-  const raised = [...after].filter(([name, count]) => count > (before.get(name) ?? 0))
-  if (raised.length === 0) return
-  refuse(
-    `gtd land: refactor-flags: the refactor may not introduce or add reads of a flag (${pattern}):\n${raised.map(([name, count]) => `  - ${name}: ${before.get(name) ?? 0} → ${count}`).join("\n")}`,
-  )
-}
-
-/** A test-file stray is never refactored: the implement turn still reads it in the naive tip. */
-export const refactorStrays = (shape: DiffShapeResult): readonly string[] =>
-  shape.strays.filter((path) => !isTestFile(path))
-
-const packageLines = (
-  strays: readonly string[],
-  pattern: string,
-  reference: string | undefined,
-): string[] => [
-  "# Behaviour-neutral refactor",
-  "",
-  "## Scope (read-only)",
-  "",
-  ...strays.map((path) => `- \`${path}\``),
-  "",
-  "This list is fixed when the package is derived: editing it here widens or narrows nothing.",
-  "",
-  "## Rules",
-  "",
-  "- The suite's outcome must not change",
-  "- Change only the paths above, plus an existing test file where a changed call shape reaches it: never add or delete a test file, and never add, remove or alter a test or an assertion",
-  `- Introduce no flag read and add no second read of an existing one (\`${pattern}\`)`,
-  "",
-  "## Reference",
-  "",
-  ...(reference === undefined
-    ? ["None."]
-    : [
-        `Reading material only, never applied: \`git show ${reference} -- ${strays.map(quote).join(" ")}\``,
-        "",
-        "Its changes to the existing code above are the seam this refactor exists to land, minus the feature's own behaviour.",
-      ]),
-  "",
-]
-
-// 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)
-  const headings = marked.map((m) =>
-    m.fenced ? undefined : /^(#{1,6}) /.exec(m.line)?.[1]?.length,
-  )
-  const shallowest = Math.min(...headings.filter((n): n is number => n !== undefined))
-  // Collected headings nest under `## Review feedback`, so the shallowest lands at `###`.
-  const shift = 3 - shallowest
-  return lines.map((line, i) => {
-    const depth = headings[i]
-    if (depth === undefined) return line
-    // Markdown has no heading past `######`.
-    return "#".repeat(Math.min(6, depth + shift)) + line.slice(depth)
-  })
-}
-
-const deriveScript = (lines: readonly string[]): string =>
-  `mkdir -p .gtd
-printf '%s\\n' ${lines.map(quote).join(" ")} > ${quote(REFACTOR_PACKAGE)}
-`
-
-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. */
-const plan = (shape: DiffShapeResult, options: RefactorOptions): Plan | undefined => {
-  if (shape.choice !== "refactor-first" || shape.unreadable.length > 0) return undefined
-  const pattern = vars.refactorFlagPattern ?? defaults.refactorFlagPattern!
-  const expression = flagExpression(pattern)
-  const strays = refactorStrays(shape)
-  if (strays.length === 0) return undefined
-  const zeroLength = strays.filter((path) => countFlags(read(path) ?? "", expression, new Map()))
-  if (zeroLength.length > 0)
-    throw new Error(
-      `gtd: refactorFlagPattern (${pattern}) produces a zero-length match in:\n${listPaths(zeroLength)}`,
-    )
-  const reference = options.reference?.trim() ? options.reference : undefined
-  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.
-// Scope and tests look at the turn's own changes: a person's edit at an escalation rest must
-// not wedge every later fix turn. Flags look at the whole range since `entry`.
-const guardOf =
-  ({ pattern, strays }: Plan, entry: string): Guard =>
-  () => {
-    requireWithin([...strays, ...requireTestCallSitesOnly()])
-    requireNoNewFlags(pattern, entry)
-  }
-
-/** 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, note } = p
-  await run(
-    "deriving",
-    deriveScript([
-      ...packageLines(strays, pattern, reference),
-      ...(note === undefined ? [] : ["## Refactor note", "", ...demoteHeadings(note), ""]),
-      ...(feedback === undefined
-        ? []
-        : ["## Review feedback", "", ...demoteHeadings(feedback), ""]),
-    ]),
-    { label: "Deriving the refactor package", file: REFACTOR_PACKAGE },
-  )
-  await t.agentWithSkills(
-    "building",
-    t.refactorBuildingPrompt({
-      pkg: REFACTOR_PACKAGE,
-      strays,
-      pattern,
-      reference,
-      feedback: feedback !== undefined,
-      note: note !== undefined,
-    }),
-    { label: "Refactoring", model: coder(), system: t.builderSystem() },
-  )
-  guard()
-  await healthy(
-    async () => {
-      await t.agentWithSkills("fix.suite.fixing", t.refactorFixPrompt(strays, pattern), {
-        label: "Fixing the check",
-        file: FEEDBACK,
-        model: coder(),
-        system: t.builderSystem(),
-      })
-      guard()
-    },
-    { describeGuard: guard, rules: t.refactorRules(strays, pattern) },
-  )
-  await run("closing", removeScript([REFACTOR_PACKAGE]), { label: "Closing out the refactor" })
-}
-
-const strayAccess = (strays: readonly string[]) => ({
-  write: [...strays, ...testFileGlobs, ".gtd/**"],
-})
-
-export const refactorFirst = async (
-  shape: DiffShapeResult,
-  options: RefactorOptions = {},
-): Promise<boolean> => {
-  const p = plan(shape, options)
-  if (p === undefined) return false
-  return scope({ name: "refactor", access: strayAccess(p.strays) }, async () => {
-    await refactorLap(p, guardOf(p, head()))
-    return true
-  })
-}
-
-/**
- * `refactorFirst` plus its review, in the one `refactor` scope so the tail's
- * steps are `refactor.build.*`. A review edit re-runs the refactor, never a
- * re-plan: the collected notes ride the re-derived package. Every round
- * reviews the whole refactor since `entry`, since each lap rebuilds over it.
- */
-export const reviewedRefactor = async (
-  shape: DiffShapeResult,
-  options: RefactorOptions = {},
-): Promise<boolean> => {
-  const p = plan(shape, options)
-  if (p === undefined) return false
-  return scope({ name: "refactor", access: strayAccess(p.strays) }, async () => {
-    const entry = head()
-    const guard = guardOf(p, entry)
-    const feedback: FeedbackTarget = {
-      file: REFACTOR_PACKAGE,
-      collecting: (capture, round) => refactorCollecting(capture, round, p.strays),
-      unmatched:
-        "gtd land: refactor-feedback: the review feedback changed files but wrote no .gtd/REFACTOR.md — a refactor cannot act on it; revert the change, or `gtd abandon` and restart",
-      dropped: t.refactorDroppedRefusal,
-    }
-    let collected: string | undefined
-    for (;;) {
-      await refactorLap(p, guard, collected)
-      // A person's edit at an escalation rest is never refused, as in the lap.
-      const outcome = await buildTail(entry, {
-        green: true,
-        guard,
-        guardRests: false,
-        lenses: lensEntriesOf(vars.refactorQualityReviews ?? ""),
-        feedback,
-        fixAccess: strayAccess(p.strays),
-        lensBase: entry,
-        rules: t.refactorRules(p.strays, p.pattern),
-        lap: "refactor",
-      })
-      if (outcome.verdict === "signoff") return true
-      await reUnwind(outcome)
-      // The kit returns `feedback` only once the collecting turn wrote the package.
-      collected = read(REFACTOR_PACKAGE)
-      if (collected === undefined)
-        throw new Error(`gtd: review feedback left no ${REFACTOR_PACKAGE}`)
-    }
-  })
-}

package/src/workflows/feature/release-flag.feature

@@ -1,167 +0,0 @@
-@inmem
-Feature: a release flag only when the requirements ask for one
-
-  A change ships unflagged unless `.gtd/REQUIREMENTS.md` carries a
-  `## Release Flag` section — written by triage, or by the skip path's impact
-  turn, only when the sketch asks for a flag, and editable at the design gate.
-  Its first line is `new` (a new release flag) or `existing: <NAME>` (behind a
-  flag that already exists). Without it no seam judge or refactor runs and the
-  naive pass lands as the implementation; with it the seam judge rules on the
-  pass.
-
-  Background:
-    Given the shipped workflows, as gtd install scaffolds them
-    And an environment variable "GTD_QUALITYREVIEWS" set to ""
-    And an environment variable "GTD_FLAG_RISK_TIER" set to "0"
-    And a file "src/calc.ts" with:
-      """
-      export const add = (a: number, b: number) => a + b
-      """
-    And the working tree is committed as "feat: add calculator"
-    And step "unwind" changes nothing
-    And step "start-gate.check" changes nothing
-    And step "seam.naive" writes "src/calc.test.ts" with:
-      """
-      it("[AC-1] subtracts", () => {})
-      """
-    And step "seam.naive" writes "src/calc.ts" with:
-      """
-      export const add = (a: number, b: number) => a + b
-      export const subtract = (a: number, b: number) => a - b
-      """
-    And step "seam.check" changes nothing
-
-  Rule: the design path
-
-    Background:
-      Given a file "TODO.md" with:
-        """
-        # Add subtract
-
-        subtract(a, b) returns the difference.
-        """
-      And step "design.gate.answer" changes nothing
-
-    Scenario: with no Release Flag section the naive pass lands unjudged, and no flag is asked for
-      Given step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
-        """
-        # Requirements
-
-        ## Impact
-
-        - the calculator module
-
-        ## Acceptance Criteria
-
-        - AC-1: subtract(a, b) returns a - b.
-        """
-      And step "implement.applying" runs its script
-      And step "implement.health.check" changes nothing
-      And step "implement.closing" runs its script
-      When the process is driven
-      Then the process rests at "build.review.reviewing"
-      And "src/calc.ts" contains "subtract"
-      And no commit body contains "seam.judge"
-      And the commit subjects end with:
-        """
-        gtd(human): design.gate.answer → seam.naive
-        gtd(agent): seam.naive → seam.check
-        gtd(check): seam.check → implement.applying
-        gtd(check): implement.applying → implement.health.check
-        gtd(check): implement.health.check → implement.closing
-        gtd(check): implement.closing → build.review.reviewing
-        """
-
-    Scenario: a new release flag asked for sends the naive pass to the seam judge
-      Given step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
-        """
-        # Requirements
-
-        ## Impact
-
-        - the calculator module
-
-        ## Release Flag
-
-        new
-
-        ## Acceptance Criteria
-
-        - AC-1: subtract(a, b) returns a - b.
-        """
-      When the process is driven
-      Then the process rests at "seam.judge"
-
-    Scenario: an existing flag asked for sends the naive pass to the seam judge too
-      Given step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
-        """
-        # Requirements
-
-        ## Impact
-
-        - the calculator module
-
-        ## Release Flag
-
-        existing: GTD_FLAG_BETA
-
-        ## Acceptance Criteria
-
-        - AC-1: subtract(a, b) returns a - b.
-        """
-      When the process is driven
-      Then the process rests at "seam.judge"
-
-    Scenario: a Release Flag section that asks for neither is refused
-      Given step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
-        """
-        # Requirements
-
-        ## Impact
-
-        - the calculator module
-
-        ## Release Flag
-
-        maybe later
-
-        ## Acceptance Criteria
-
-        - AC-1: subtract(a, b) returns a - b.
-        """
-      Then driving the process is refused with "release-flag"
-
-  Rule: the skip path
-
-    Background:
-      Given a file "TODO.md" with:
-        """
-        # Add subtract
-
-        Ship it behind the existing GTD_FLAG_BETA flag.
-
-        ## Acceptance criteria
-
-        - subtract(a, b) returns a - b.
-        """
-      And judge step "design.clear" answers:
-        """
-        [{"id":"clear","answer":"yes","p":0.9}]
-        """
-      And step "design.normalise" runs its script
-
-    Scenario: the impact turn records the flag the sketch asks for, and the seam judge rules
-      Given step "design.impact" appends to ".gtd/REQUIREMENTS.md":
-        """
-
-        ## Impact
-
-        - the calculator module
-
-        ## Release Flag
-
-        existing: GTD_FLAG_BETA
-        """
-      When the process is driven
-      Then the process rests at "seam.judge"
-      And ".gtd/REQUIREMENTS.md" contains "existing: GTD_FLAG_BETA"

package/src/workflows/feature/release-flag.test.ts

@@ -1,49 +0,0 @@
-import { describe, expect, it } from "vitest"
-import { releaseFlagOf } from "./release-flag.js"
-
-const requirements = (section: string): string =>
-  `# Requirements\n\n## Impact\n\n- a module\n\n${section}## Acceptance Criteria\n\n- AC-1: a\n`
-
-describe("releaseFlagOf", () => {
-  it("asks for no flag without the section, or with none", () => {
-    expect(releaseFlagOf(requirements(""))).toEqual({ kind: "none" })
-    expect(releaseFlagOf(requirements("## Release Flag\n\nnone\n\n"))).toEqual({ kind: "none" })
-  })
-
-  it("reads new and an existing flag's name, backticked or not", () => {
-    expect(releaseFlagOf(requirements("## Release Flag\n\nnew\n\n"))).toEqual({ kind: "new" })
-    for (const line of [
-      "existing: GTD_FLAG_BETA",
-      "existing: `GTD_FLAG_BETA`",
-      "Existing:GTD_FLAG_BETA",
-    ])
-      expect(releaseFlagOf(requirements(`## Release Flag\n\n${line}\n\n`))).toEqual({
-        kind: "existing",
-        name: "GTD_FLAG_BETA",
-      })
-  })
-
-  it("reads only the first line under the heading, and only a level-2 heading", () => {
-    expect(
-      releaseFlagOf(requirements("## Release Flag\n\nnew\n\nbecause the sketch says so\n\n")),
-    ).toEqual({
-      kind: "new",
-    })
-    expect(releaseFlagOf(requirements("### Release Flag\n\nnew\n\n"))).toEqual({ kind: "none" })
-  })
-
-  it("ignores a fenced heading", () => {
-    expect(releaseFlagOf(requirements("```\n## Release Flag\n\nnew\n```\n\n"))).toEqual({
-      kind: "none",
-    })
-  })
-
-  it("names the line it cannot read", () => {
-    expect(releaseFlagOf(requirements("## Release Flag\n\nmaybe later\n\n"))).toEqual({
-      unreadable: "maybe later",
-    })
-    expect(releaseFlagOf(requirements("## Release Flag\n\nexisting:\n\n"))).toEqual({
-      unreadable: "existing:",
-    })
-  })
-})

package/src/workflows/feature/release-flag.ts

@@ -1,46 +0,0 @@
-import { read, refuse } from "../../flows/index.js"
-import { HEADING, markFenced } from "../shared/fences.js"
-import { REQUIREMENTS } from "../shared/steps.js"
-import type { ReleaseFlag } from "../shared/text.js"
-
-const NAME = /^existing:\s*`?([A-Za-z_][\w.-]*)`?$/i
-
-const isFlagHeading = (h: RegExpExecArray | null): boolean =>
-  h !== null && h[1]!.length === 2 && /^release flag$/i.test(h[2]!.trim())
-
-/** The first line under `## Release Flag`, `undefined` without the section. */
-const requestLine = (text: string): string | undefined => {
-  const lines = markFenced(text)
-  const at = lines.findIndex((l) => !l.fenced && isFlagHeading(HEADING.exec(l.line)))
-  if (at === -1) return undefined
-  const body = lines.slice(at + 1)
-  const end = body.findIndex((l) => !l.fenced && HEADING.test(l.line))
-  return (end === -1 ? body : body.slice(0, end)).find((l) => l.line.trim() !== "")?.line.trim()
-}
-
-/** What `text` asks for, or why it cannot be read. No section asks for no flag. */
-export const releaseFlagOf = (text: string): ReleaseFlag | { readonly unreadable: string } => {
-  const line = requestLine(text)
-  if (line === undefined || /^none$/i.test(line)) return { kind: "none" }
-  if (/^new$/i.test(line)) return { kind: "new" }
-  const name = NAME.exec(line)?.[1]
-  return name === undefined ? { unreadable: line } : { kind: "existing", name }
-}
-
-/** Refuse `file` when its `## Release Flag` section is neither `none`, `new` nor `existing: <NAME>`. */
-export const requireReleaseFlag = (file: string): void => {
-  const request = releaseFlagOf(read(file) ?? "")
-  if (!("unreadable" in request)) return
-  refuse(
-    `gtd land: release-flag: ${file}'s "## Release Flag" reads ${JSON.stringify(request.unreadable)} — its first line must be \`new\`, \`existing: <NAME>\` or \`none\`, or leave the section out for no flag`,
-  )
-}
-
-/** What `.gtd/REQUIREMENTS.md` asks for now; a person's unreadable edit is refused. */
-export const requestedFlag = (): ReleaseFlag => {
-  requireReleaseFlag(REQUIREMENTS)
-  return releaseFlagOf(read(REQUIREMENTS) ?? "") as ReleaseFlag
-}
-
-/** Whether the change goes behind a release flag: only then does the seam judge rule. */
-export const flagged = (): boolean => requestedFlag().kind !== "none"