@pmelab/gtd 28.2.0 → 29.0.0

package/src/workflows/feature/review.ts

@@ -3,13 +3,17 @@ import {
   head,
   judge,
   numeric,
+  requireRevert,
+  restoreScript,
+  run,
   vars,
   type JudgeQuestion,
   type Judgment,
+  type ScopeAccess,
 } from "../../flows/index.js"
 import type { ReviewNote } from "../../steering/index.js"
 import * as kit from "../../workflow-kit/index.js"
-import { healthy, type EscalationCount } from "../shared/health.js"
+import { guarded, healthy, type EscalationCount, type Guard } from "../shared/health.js"
 import {
   awaitReview,
   fixCheck,
@@ -165,21 +169,29 @@ const isCode = (path: string): boolean => path !== ".gtd" && !path.startsWith(".
 export const review = (
   base: string,
   escalations: EscalationCount = { rounds: 0 },
+  options: BuildTailOptions = {},
 ): Promise<kit.ReviewOutcome> => {
+  const { guard, guardRests, fixAccess, rules } = options
+  const feedback: FeedbackTarget = options.feedback ?? {
+    file: REQUIREMENTS,
+    collecting,
+    unmatched:
+      "gtd land: no declared pattern matches the pending changes — write .gtd/REQUIREMENTS.md from the feedback, or change nothing when it asks for nothing",
+  }
   const severities = new Map<string, Severity>()
   // Armed by a defer-only round to pick the next gate's message; a fresh
   // review (`reviewing`) disarms it.
   let deferred: readonly t.NoteInput[] = []
   return kit.review(base, {
     file: REVIEW,
-    feedback: REQUIREMENTS,
+    feedback: feedback.file,
     isCode,
     reviewing: (b, carry) => {
       deferred = []
-      return reviewing(b, carry)
+      return reviewing(b, carry, options.lap)
     },
-    fixRisks,
-    keepGreen: () => healthy(fixCheck, { escalations }),
+    fixRisks: guarded((notes) => fixRisks(notes, fixAccess, rules), guard),
+    keepGreen: () => healthy(() => fixCheck(rules), { escalations, guard, guardRests, rules }),
     awaitReview: (b) => {
       const notes = deferred
       deferred = []
@@ -188,7 +200,7 @@ export const review = (
         : awaitReview(b)
     },
     reviewMissing,
-    collecting,
+    collecting: feedback.collecting,
     triage: triage(severities),
     defer: (notes) => {
       deferred = notes.map((n) => ({
@@ -200,7 +212,7 @@ export const review = (
       return deferNotes(deferred, head())
     },
     answerQuestions: answerReviewQuestions,
-    fixNits,
+    fixNits: guarded((notes) => fixNits(notes, fixAccess, rules), guard),
     close: closeReview,
     captures: {
       edits: t.reviewEditsCapture,
@@ -229,15 +241,70 @@ export const review = (
     refusals: {
       deleted:
         "gtd land: review-doc: .gtd/REVIEW.md was deleted — restore it, or leave a note (or edit code) to request changes.",
-      unmatched:
-        "gtd land: no declared pattern matches the pending changes — write .gtd/REQUIREMENTS.md from the feedback, or change nothing when it asks for nothing",
+      unmatched: feedback.unmatched,
+      ...(feedback.dropped === undefined ? {} : { dropped: feedback.dropped }),
     },
   })
 }
 
+export interface FeedbackTarget {
+  readonly file: string
+  readonly collecting: (capture: string, round: kit.CollectRound) => Promise<void>
+  /** Refusal when the collecting turn changed something but not `file`. */
+  readonly unmatched: string
+  readonly dropped?: (requested: kit.Requested) => string
+}
+
+export interface BuildTailOptions {
+  /** Runs after every code-changing turn: fix-check, quality fix, risk fix, nit fix, escalation describe. */
+  readonly guard?: Guard
+  /** `false`: `guard` skips the escalation's human rests. */
+  readonly guardRests?: boolean
+  /** Quality-lap lenses; default `lensesOf(vars.qualityReviews)`. */
+  readonly lenses?: readonly string[]
+  readonly feedback?: FeedbackTarget
+  /** Write access for the nit and risk fix turns; absent: the bundled `access` export decides. */
+  readonly fixAccess?: ScopeAccess
+  /** The commit the quality lap reviews from; absent: `start()`. */
+  readonly lensBase?: string
+  /** Appended to every fix and describe prompt of the tail. */
+  readonly rules?: string
+  /** Absent: "first". */
+  readonly lap?: t.ReviewRange
+}
+
 /** The build tail: fix (when entered red), keep green unless `green`, the quality lap, then human review since `base`. */
 export const buildTail = (
   fixFirst: boolean,
   base: string,
   green = false,
-): Promise<kit.ReviewOutcome> => tail(fixFirst, (escalations) => review(base, escalations), green)
+  options: BuildTailOptions = {},
+): Promise<kit.ReviewOutcome> =>
+  tail(
+    fixFirst,
+    (escalations) => review(base, escalations, options),
+    green,
+    options.guard,
+    options.lenses,
+    options.guardRests,
+    options.lensBase,
+    options.rules,
+  )
+
+/**
+ * Undo the human's review-round code edits. A path changed since the human
+ * left it is not overwritten; requireRevert names it instead.
+ */
+export const reUnwind = async (
+  feedback: Extract<kit.ReviewOutcome, { verdict: "feedback" }>,
+): Promise<void> => {
+  const { base, restoreFrom, edited } = feedback
+  const restore = edited.filter((c) => c.status !== "added").map((c) => c.path)
+  const remove = edited.filter((c) => c.status === "added").map((c) => c.path)
+  await run("re-unwind", restoreScript(base, { restore, remove }, restoreFrom), {
+    label: "Re-unwinding your review edit",
+    file: REVIEW,
+    base,
+  })
+  requireRevert(edited, base)
+}

package/src/workflows/feature/seam-rejection.feature

@@ -143,4 +143,8 @@ Feature: rejected naive passes walk one fixed path through the steer gate to idl
     And the commit "gtd(judge): seam.judge → seam.steer" has a body containing "\"answer\":\"reject\""
     And the commit "gtd(judge): seam.judge → implement.building" has a body containing "\"answer\":\"land\""
     And no commit body contains "Gtd-Approved:"
+    And the output lines of gtd "slices" start with:
+      """
+      feature 
+      """
     And no commit body contains "Gtd-Workflow:"

package/src/workflows/feature/seam.feature

@@ -222,7 +222,7 @@ Feature: the naive pass and seam judge replace architecture behind GTD_FLAG_NAIV
       gtd(human): seam.steer → implement.building
       """
 
-  Scenario: review feedback re-runs design and the whole seam phase
+  Scenario: review feedback after land re-runs design and implement, never the seam phase
     Given step "seam.naive" writes "src/calc.ts" with:
       """
       export const add = (a: number, b: number) => b + a
@@ -311,10 +311,9 @@ Feature: the naive pass and seam judge replace architecture behind GTD_FLAG_NAIV
     Then the process rests at "implement.building"
     And the commit subjects end with:
       """
+      gtd(check): build.review.closing → re-unwind
       gtd(check): re-unwind → design.triage
       gtd(agent): design.triage → design.gate.answer
-      gtd(human): design.gate.answer → seam.naive
-      gtd(agent): seam.naive → seam.judge
-      gtd(judge): seam.judge → implement.building
+      gtd(human): design.gate.answer → implement.building
       gtd(agent): implement.building
       """

package/src/workflows/feature/seam.test.ts

@@ -8,7 +8,7 @@ import {
 } from "../../flows/index.js"
 import { globMatches } from "../../wire/index.js"
 import { fixtureContext } from "../shared/text.fixture.js"
-import { judgeSeam, naivePass } from "./seam.js"
+import { implement, judgeSeam, naivePass, seamBuild, type SeamOutcome } from "./seam.js"
 import { captureStep } from "../shared/text.fixture.js"
 
 afterEach(() => installContext(undefined))
@@ -86,3 +86,198 @@ describe("naivePass", () => {
     expect(request.prompt).toContain("0.8")
   })
 })
+
+const REVIEW = ".gtd/REVIEW.md"
+const REFACTOR = ".gtd/REFACTOR.md"
+const reviewDoc = [
+  "# Review: abc1234",
+  "",
+  "<!-- base: 0000000000000000000000000000000000000000 -->",
+  "",
+  "## calc",
+  "- [ ] ./src/a.ts#1-1",
+  "add",
+  "",
+].join("\n")
+
+interface Seamed {
+  readonly names: string[]
+  readonly slices: string[]
+  /** Slice names entered, with the steps seen while inside each. */
+  readonly inside: Record<string, string[]>
+  readonly outcome: SeamOutcome | Error
+}
+
+/** Runs `seamBuild` against a scripted context: the judge answers `answer`, every review signs off. */
+const driveSeam = async (
+  answer: string,
+  stray: Change = change("src/a.ts", "modified"),
+  vars: Record<string, string> = {},
+): Promise<Seamed> => {
+  const names: string[] = []
+  const slices: string[] = []
+  const inside: Record<string, string[]> = {}
+  const stack: string[] = []
+  const open: string[] = []
+  const files = new Map<string, string>([["src/a.ts", "a"]])
+  let current = "c0"
+  const effects: Record<string, () => void> = {
+    deriving: () => void files.set(REFACTOR, "package"),
+    closing: () => void files.delete(REFACTOR),
+    "review.reviewing": () => void files.set(REVIEW, reviewDoc),
+    "review.closing": () => {
+      files.delete(REVIEW)
+      current = "after-refactor"
+    },
+  }
+  installContext({
+    ...fixtureContext({ vars: { refactorQualityReviews: "", ...vars } }),
+    matches: globMatches,
+    refuse: (message: string) => {
+      throw new Error(message)
+    },
+    pushScope: (scope: { name?: string }) => void stack.push(scope.name ?? ""),
+    popScope: () => void stack.pop(),
+    enterSlice: (name: string) => {
+      slices.push(name)
+      open.push(name)
+      inside[name] = []
+    },
+    leaveSlice: () => void open.pop(),
+    read: (path: string) => files.get(path),
+    head: () => current,
+    kept: () => tip(stray),
+    changes: () => [],
+    changesSince: () => [],
+    step: (request: StepRequest) => {
+      if (request.kind === "restart") return Promise.resolve()
+      const full = [...stack, request.name].join(".")
+      names.push(full)
+      for (const name of open) inside[name]!.push(full)
+      effects[request.name]?.()
+      if (request.kind === "judge")
+        return Promise.resolve({ answers: { shape: { answer, p: 0.9 } }, truncated: [] })
+      return Promise.resolve(undefined)
+    },
+  } as unknown as FlowContext)
+  let outcome: SeamOutcome | Error
+  try {
+    outcome = await seamBuild("c-base")
+  } catch (error) {
+    outcome = error as Error
+  }
+  return { names, slices, inside, outcome }
+}
+
+describe("seamBuild", () => {
+  it("land resolves the kept tip with the caller's base and enters no slice", async () => {
+    const h = await driveSeam("land")
+    expect(h.outcome).toEqual({ reference: "abc", base: "c-base" })
+    expect(h.slices).toEqual([])
+    expect(h.names).toEqual(["seam.naive", "seam.judge"])
+  })
+
+  it("refactor-first runs the reviewed refactor in slice refactor and resolves HEAD after it", async () => {
+    const h = await driveSeam("refactor-first")
+    expect(h.outcome).toEqual({ reference: "abc", base: "after-refactor" })
+    expect(h.slices).toEqual(["refactor"])
+    expect(h.inside.refactor![0]).toBe("refactor.deriving")
+    expect(h.inside.refactor).toContain("refactor.build.review.closing")
+    expect(h.names.some((n) => n.includes("approve"))).toBe(false)
+    expect(h.names.some((n) => n.startsWith("implement"))).toBe(false)
+  })
+
+  it("refactor-first with only test-file strays resolves the caller's base with no slice and no by-hand", async () => {
+    const h = await driveSeam("refactor-first", change("src/a.test.ts", "modified"), {
+      seamAllow: ".gtd/**",
+    })
+    expect(h.outcome).toEqual({ reference: "abc", base: "c-base" })
+    expect(h.slices).toEqual([])
+    expect(h.names).not.toContain("seam.by-hand")
+    expect(h.names.some((n) => n.startsWith("refactor"))).toBe(false)
+  })
+
+  it("rests an unreadable test-file stray at seam.by-hand", async () => {
+    const h = await driveSeam(
+      "refactor-first",
+      { path: "src/a.test.ts", status: "modified", before: undefined, after: "b" },
+      { seamAllow: ".gtd/**" },
+    )
+    expect(h.slices).toEqual([])
+    expect(h.names).toContain("seam.by-hand")
+  })
+
+  it("rests unreadable strays at seam.by-hand and enters no refactor slice", async () => {
+    const h = await driveSeam("refactor-first", {
+      path: "src/a.ts",
+      status: "modified",
+      before: undefined,
+      after: "b",
+    })
+    expect(h.slices).toEqual([])
+    expect(h.names).toContain("seam.by-hand")
+    expect(h.outcome).toEqual({ reference: "abc", base: "c-base" })
+  })
+})
+
+describe("implement", () => {
+  const building = async (
+    reference: string | undefined,
+    tier?: "low" | "high",
+    amend?: boolean,
+  ) => {
+    const requests: StepRequest[] = []
+    installContext(
+      fixtureContext(
+        {},
+        {
+          step: (request: StepRequest) => {
+            requests.push(request)
+            return Promise.resolve()
+          },
+          pushScope: () => undefined,
+          popScope: () => undefined,
+          changesSince: () => [],
+        },
+      ),
+    )
+    await implement(reference, tier, amend)
+    const request = requests.find((r) => r.kind === "agent" && r.name === "building")
+    if (request?.kind !== "agent") throw new Error("no building turn")
+    return request.prompt
+  }
+
+  it("names the reference with a git show line", async () => {
+    expect(await building("abc")).toContain("git show abc")
+  })
+
+  it("carries no git show line without a reference", async () => {
+    expect(await building(undefined)).not.toContain("git show")
+  })
+
+  it("first lap renders the reference line and the fresh-write wording", async () => {
+    const prompt = await building("abc")
+    expect(prompt).toContain("git show abc")
+    expect(prompt).toContain("Implement them properly")
+    expect(prompt).toContain("write\n  the change fresh")
+    expect(prompt).toContain("new release flag")
+  })
+
+  it("amend says the change exists, keeps the earlier flag and asks for no new one", async () => {
+    const prompt = await building(undefined, undefined, true)
+    expect(prompt).toContain("already exists")
+    expect(prompt).toContain("amend")
+    expect(prompt).toContain("Keep the release flag")
+    expect(prompt).toContain("if it added one")
+    expect(prompt).not.toContain("implement them properly")
+    expect(prompt).not.toContain("Implement them properly")
+    expect(prompt).not.toContain("write the change fresh")
+    expect(prompt).toContain("otherwise put")
+  })
+
+  it("amend on tier low says to add no release flag", async () => {
+    const prompt = await building(undefined, "low", true)
+    expect(prompt).toContain("Add no release flag")
+    expect(prompt).toContain("amend")
+  })
+})

package/src/workflows/feature/seam.ts

@@ -1,12 +1,13 @@
 import {
   changes,
+  head,
   human,
   judgeDiffShape,
   kept,
   removeScript,
   run,
   scope,
-  seamGate,
+  slice,
   vars,
   type DiffShapeResult,
   type KeptTip,
@@ -15,7 +16,7 @@ import { healthy } from "../shared/health.js"
 import { coder, FEEDBACK, REQUIREMENTS } from "../shared/steps.js"
 import * as t from "../shared/text.js"
 import { defaults } from "../shared/vars.js"
-import { refactorFirst } from "./refactor.js"
+import { refactorStrays, reviewedRefactor } from "./refactor.js"
 import type { RiskTier } from "./tier.js"
 
 /** Naive-pass retries after a `reject`; the next `reject` rests at `seam.steer`. */
@@ -40,9 +41,13 @@ export const naivePass = (rejection?: t.SeamRejection): Promise<void> =>
     system: t.builderSystem(),
   })
 
-export const implement = (reference: string, tier?: RiskTier): Promise<void> =>
+export const implement = (
+  reference: string | undefined,
+  tier?: RiskTier,
+  amend?: boolean,
+): Promise<void> =>
   scope("implement", async () => {
-    await t.agentWithSkills("building", t.implementBuildingPrompt(reference, tier), {
+    await t.agentWithSkills("building", t.implementBuildingPrompt(reference, tier, amend), {
       label: "Implementing",
       model: coder(),
       system: t.builderSystem(),
@@ -74,7 +79,6 @@ const decide = (): Promise<Decision> =>
       const shape = await judgeSeam(tip)
       if (shape.choice === "land") return { reference: tip.hash }
       if (shape.choice === "refactor-first") {
-        await seamGate("approve", shape)
         return { reference: tip.hash, shape }
       }
       rejection = { strays: shape.strays, p: shape.judgment?.answers.shape?.p ?? 0 }
@@ -95,10 +99,17 @@ const decide = (): Promise<Decision> =>
     }
   })
 
-export const seamBuild = async (tier?: RiskTier): Promise<void> => {
+export interface SeamOutcome {
+  /** The naive pass's kept tip: the first implement turn's reading material. */
+  readonly reference: string
+  /** The feature review's base: HEAD after the refactor on refactor-first, else the caller's base. */
+  readonly base: string
+}
+
+export const seamBuild = async (base: string): Promise<SeamOutcome> => {
   const { reference, shape } = await decide()
-  if (shape !== undefined && !(await refactorFirst(shape, { reference }))) {
-    // Unreadable strays were never judged, and no refactor runs: a person reads the diff.
+  if (shape === undefined) return { reference, base }
+  if (shape.unreadable.length > 0) {
     await scope("seam", () =>
       human("by-hand", {
         message: t.seamByHandMessage(shape.strays, shape.unreadable, reference),
@@ -106,6 +117,9 @@ export const seamBuild = async (tier?: RiskTier): Promise<void> => {
         acceptClean: true,
       }),
     )
+    return { reference, base }
   }
-  await implement(reference, tier)
+  if (refactorStrays(shape).length === 0) return { reference, base }
+  await slice("refactor", () => reviewedRefactor(shape, { reference }))
+  return { reference, base: head() }
 }

package/src/workflows/feature/steps.test.ts

@@ -1,6 +1,7 @@
+import { readFileSync } from "node:fs"
 import { describe, expect, it } from "vitest"
-import type { StepRequest } from "../../flows/index.js"
-import { captureStep } from "../shared/text.fixture.js"
+import { installContext, type ScopeOptions, type StepRequest } from "../../flows/index.js"
+import { captureStep, fixtureContext } from "../shared/text.fixture.js"
 import * as steps from "./steps.js"
 
 const capture = (
@@ -45,6 +46,30 @@ describe("the feature workflow's own steps declare skills — a step's rendered
     expect(prompt).toContain("code-review-and-quality")
   })
 
+  it("collecting's prompt is the pinned feature fixture", async () => {
+    const prompt = agentPrompt(await capture(() => steps.collecting("capture-text"), "build"))
+    expect(prompt).toContain(
+      readFileSync(
+        new URL("../shared/__fixtures__/feature-collecting-prompt.txt", import.meta.url),
+        "utf8",
+      ),
+    )
+  })
+
+  it("refactorCollecting renders the open variant for the reply round, the closed one otherwise, whatever .gtd/REVIEW.md holds", async () => {
+    const at = (round: "reply" | "edits", present: boolean): Promise<StepRequest> =>
+      captureStep(() => steps.refactorCollecting("capture", round, ["src/a.ts"]), {
+        scope: "refactor.build",
+        read: (path) => (present && path === ".gtd/REVIEW.md" ? "# Review" : undefined),
+      })
+    const open = agentPrompt(await at("reply", false))
+    const closed = agentPrompt(await at("edits", true))
+    expect(open).toContain("exactly one `- A:` reply")
+    expect(open).not.toContain("already closed")
+    expect(closed).toContain("already closed")
+    expect(closed).not.toContain("exactly one `- A:` reply")
+  })
+
   it("answerReviewQuestions answers inline in .gtd/REVIEW.md as the reviewer, with its bundled skills", async () => {
     const request = await capture(
       () =>
@@ -80,6 +105,33 @@ describe("the feature workflow's own steps declare skills — a step's rendered
     expect(request.prompt).toContain("Leave `.gtd/REVIEW.md` untouched")
   })
 
+  it("fixNits with access runs in a review.fix.nits scope, the step named fixing inside it", async () => {
+    const scopes: ScopeOptions[] = []
+    const steps_: StepRequest[] = []
+    const access = { write: ["src/a.ts", ".gtd/**"] }
+    installContext(
+      fixtureContext(
+        { scope: "refactor.build" },
+        {
+          step: (request) => {
+            steps_.push(request)
+            return Promise.resolve()
+          },
+          pushScope: (s) => void scopes.push(s),
+          popScope: () => undefined,
+          changesSince: () => [],
+        },
+      ),
+    )
+    try {
+      await steps.fixNits([], access)
+    } finally {
+      installContext(undefined)
+    }
+    expect(scopes).toEqual([{ name: "review.fix.nits", access }])
+    expect(steps_.map((r) => ("name" in r ? r.name : ""))).toEqual(["fixing"])
+  })
+
   it("deferNotes rests at build.review.defer as a script writing .gtd/TODO.md", async () => {
     const request = await capture(
       () =>

package/src/workflows/feature/steps.ts

@@ -1,7 +1,16 @@
-import { human, run } from "../../flows/index.js"
+import { human, run, scope, type ScopeAccess } from "../../flows/index.js"
+import type { CollectRound } from "../../workflow-kit/index.js"
 import * as t from "../shared/text.js"
 import { riskTierOn } from "./tier.js"
-import { ARCHITECTURE, coder, FEEDBACK, planner, REQUIREMENTS, REVIEW } from "../shared/steps.js"
+import {
+  ARCHITECTURE,
+  coder,
+  FEEDBACK,
+  planner,
+  REFACTOR,
+  REQUIREMENTS,
+  REVIEW,
+} from "../shared/steps.js"
 
 /** Turn the sketch since `base` into `.gtd/REQUIREMENTS.md`. */
 export const triage = (base: string): Promise<void> =>
@@ -73,13 +82,22 @@ export const answerReviewQuestions = (notes: readonly t.NoteInput[]): Promise<vo
   })
 
 /** Fix every `nit` note in one turn. */
-export const fixNits = (notes: readonly t.NoteInput[]): Promise<void> =>
-  t.agentWithSkills("review.fix.nits.fixing", t.buildReviewFixNitsPrompt(notes), {
-    label: "Fixing your nits",
-    file: REVIEW,
-    model: planner(),
-    system: t.reviewerSystem(),
-  })
+export const fixNits = (
+  notes: readonly t.NoteInput[],
+  access?: ScopeAccess,
+  rules?: string,
+): Promise<void> => {
+  const fixing = (name: string): Promise<void> =>
+    t.agentWithSkills(name, t.buildReviewFixNitsPrompt(notes, rules), {
+      label: "Fixing your nits",
+      file: REVIEW,
+      model: planner(),
+      system: t.reviewerSystem(),
+    })
+  return access === undefined
+    ? fixing("review.fix.nits.fixing")
+    : scope({ name: "review.fix.nits", access }, () => fixing("fixing"))
+}
 
 /** Turn the review round `capture` describes into `.gtd/REQUIREMENTS.md`, or change nothing. */
 export const collecting = (capture: string): Promise<void> =>
@@ -92,6 +110,24 @@ export const collecting = (capture: string): Promise<void> =>
     allowEmpty: true,
   })
 
+/** Turn the refactor review round `capture` describes into `.gtd/REFACTOR.md`, or change nothing. */
+export const refactorCollecting = (
+  capture: string,
+  round: CollectRound,
+  strays: readonly string[],
+): Promise<void> =>
+  t.agentWithSkills(
+    "review.collecting",
+    t.buildReviewCollectingPrompt(capture, { strays, round }),
+    {
+      label: "Collecting your refactor feedback",
+      file: REFACTOR,
+      model: planner(),
+      system: t.reviewerSystem(),
+      allowEmpty: true,
+    },
+  )
+
 /** `build.review.defer`: append `notes` to `.gtd/TODO.md` as one section; the step's landing is the commit. */
 export const deferNotes = (notes: readonly t.NoteInput[], round: string): Promise<void> =>
   run("review.defer", t.deferNotesScript(notes, round), {

package/src/workflows/feature/tier.test.ts

@@ -77,6 +77,10 @@ describe("readRiskTier fences", () => {
     const text = "````\n```\n## Risk Tier\n\nlow\n````\n"
     expect(readRiskTier(text)).toBe("high")
   })
+
+  it("does not open a fence on a backtick line indented 4 spaces", () => {
+    expect(readRiskTier("    ```\n## Risk Tier\n\nlow\n")).toBe("low")
+  })
 })
 
 describe("readRiskTier fence closers", () => {

package/src/workflows/feature/tier.ts

@@ -1,4 +1,5 @@
 import { mark, read, vars } from "../../flows/index.js"
+import { markFenced } from "../shared/fences.js"
 import { REQUIREMENTS } from "../shared/steps.js"
 
 export type RiskTier = "low" | "high"
@@ -6,32 +7,13 @@ export type RiskTier = "low" | "high"
 /** GTD_FLAG_NAIVE_PASS, GTD_FLAG_RISK_TIER: both pinned at process start, so a mid-process flip never moves a process. */
 export const riskTierOn = (): boolean => vars.flag_naive_pass === "1" && vars.flag_risk_tier === "1"
 
-// An unclosed fence runs to end of file, so the tier reads `high` (fail-closed). A backtick
-// opener with a backtick in its info string still counts as a fence: deviates from CommonMark,
-// worst case is `high`.
-const markFenced = (text: string): readonly { line: string; fenced: boolean }[] => {
-  let fence: string | undefined // the opener run, e.g. "````"
-  return text.split(/\r?\n/).map((line) => {
-    const run = /^ {0,3}(`{3,}|~{3,})/.exec(line)?.[1]
-    const fenced = fence !== undefined || run !== undefined
-    if (fence === undefined) fence = run
-    else if (
-      run !== undefined &&
-      run[0] === fence[0] &&
-      run.length >= fence.length &&
-      /^ {0,3}(`+|~+)[ \t]*$/.test(line)
-    )
-      fence = undefined
-    return { line, fenced }
-  })
-}
-
 const sectionLines = (
   text: string | undefined,
   title: string,
 ): readonly { line: string; fenced: boolean }[] => {
   if (text === undefined) return []
   const heading = new RegExp(`^##[ \\t]+${title}[ \\t]*$`, "i")
+  // An unclosed fence hides the rest, so the tier reads `high` (fail-closed).
   const lines = markFenced(text)
   const start = lines.findIndex((l) => !l.fenced && heading.test(l.line))
   if (start < 0) return []