@pmelab/gtd 37.0.0 → 38.0.0

package/src/workflows/feature/criteria.ts

@@ -8,7 +8,7 @@ import {
   scope,
   type Change,
 } from "../../flows/index.js"
-import { markFenced } from "../shared/fences.js"
+import { HEADING, ITEM, markFenced } from "../shared/fences.js"
 import { REQUIREMENTS } from "../shared/steps.js"
 import * as t from "../shared/text.js"
 
@@ -29,8 +29,6 @@ export interface StatedCriteria {
 /** Below this the judge's `yes` is not trusted: a wrong skip builds against criteria nobody can check. */
 const CLEAR_MIN_P = 0.8
 
-const HEADING = /^ {0,3}(#{1,6})\s+(.*?)\s*#*\s*$/
-const ITEM = /^ ?(?:[-*+]|\d+[.)])\s+(?:\[[ xX]\]\s+)?(.*)$/
 const ID = /^(AC-\d+):\s*(.*)$/
 
 /** The list items under the first heading `title` matches (at `level` when given), up to the next heading; wrapped lines joined, fenced lines ignored. */
@@ -71,6 +69,31 @@ export const criteriaOf = (text: string): readonly Criterion[] | undefined =>
     return id === null ? { id: "", text: item } : { id: id[1]!, text: id[2]! }
   })
 
+/**
+ * Which criteria one slice builds, resolved against the file whenever read:
+ * `only` drops an ID a steer deleted, `except` (the last slice) takes one a
+ * steer added.
+ */
+export interface CriteriaSlice {
+  readonly only?: readonly string[]
+  readonly except?: readonly string[]
+}
+
+/** The ID'd criteria of `text`, only `slice`'s when given. */
+export const criterionIds = (text: string, slice?: CriteriaSlice): string[] =>
+  (criteriaOf(text) ?? [])
+    .map((c) => c.id)
+    .filter(
+      (id) =>
+        id !== "" &&
+        (slice?.only === undefined || slice.only.includes(id)) &&
+        !(slice?.except ?? []).includes(id),
+    )
+
+/** `slice`'s IDs in `.gtd/REQUIREMENTS.md` as it is now; `undefined` for an unsliced change. */
+export const sliceIds = (slice: CriteriaSlice | undefined): string[] | undefined =>
+  slice === undefined ? undefined : criterionIds(read(REQUIREMENTS) ?? "", slice)
+
 /** Items numbered `AC-1`…, unless every one already carries its own distinct ID. */
 const numbered = (items: readonly string[]): Criterion[] => {
   const ids = items.map((item) => ID.exec(item))

package/src/workflows/feature/feature.ts

@@ -11,21 +11,29 @@ import {
 } from "../../flows/index.js"
 import { gate, healthy } from "../shared/health.js"
 import { flagModeOn, shipped } from "../shared/options.js"
-import { FEEDBACK, fixCheck, QUALITY } from "../shared/steps.js"
+import { FEEDBACK, fixCheck, QUALITY, REQUIREMENTS } from "../shared/steps.js"
 import { refusePendingHandOff, tail } from "../shared/tail.js"
 import * as t from "../shared/text.js"
-import { skipDesign, statedCriteria, type StatedCriteria } from "./criteria.js"
+import {
+  requireCriteriaFrozen,
+  skipDesign,
+  sliceIds,
+  statedCriteria,
+  type CriteriaSlice,
+  type StatedCriteria,
+} from "./criteria.js"
 import { design } from "./planning.js"
 import { buildTail, isCode, reUnwind, type ReviewOutcome } from "./review.js"
-import { implement, seamBuild } from "./seam.js"
-import { recordRisk, riskTierOn } from "./tier.js"
+import { closeOut, implement, seamBuild } from "./seam.js"
+import { sliceCap, sliceCriteria, slicing } from "./slicing.js"
+import { recordRisk, riskTierOn, type RiskTier } from "./tier.js"
 
 // The ordinary start. Any change to the tree starts a process: `idle` →
 // `unwind` reverts the sketch (its intent survives in history) → a
-// green-baseline gate → design → a naive pass, judged with `flagMode` on: it
-// lands as the implementation, or (refactoring first when the judge asks) is
-// built fresh from → the health loop → the quality lap, and the episode ends
-// back at `idle`. Human review is the `review` door's.
+// green-baseline gate → design → per slice of the criteria, a naive pass,
+// judged with `flagMode` on: it lands as the implementation, or (refactoring
+// first when the judge asks) is built fresh from → the health loop → the
+// quality lap, and the episode ends back at `idle`. Human review is the `review` door's.
 
 /** Revert the sketch that started the process out of the working tree; its intent survives in history. */
 export const unwind = (): Promise<void> => {
@@ -37,27 +45,67 @@ export const unwind = (): Promise<void> => {
 
 export { reUnwind }
 
-/** A naive pass (judged only with `flagMode` on), then implement and the quality lap; design must have run since `firstBase`. */
+/**
+ * The slices `design.slicing` grouped the criteria into, each built in turn
+ * from where the previous one landed; design must have run since `firstBase`.
+ */
 export const buildFeature = async (firstBase: string): Promise<void> => {
   const tier = riskTierOn() ? recordRisk() : undefined
-  const seam = await seamBuild(firstBase)
-  await slice("feature", async () => {
+  const slices = await slicing()
+  // A single slice keeps the unnumbered names and builds against every criterion.
+  const one = slices.length === 1
+  for (const i of slices.keys()) {
+    const more = i < slices.length - 1
+    const criteria = sliceCriteria(slices, i)
+    // A steer may have deleted every criterion of a later slice: nothing to build.
+    if (sliceIds(criteria)?.length === 0) {
+      if (!more) await closeOut()
+      continue
+    }
+    const n = one ? "" : `-${i + 1}`
+    await buildSlice(i === 0 ? firstBase : head(), {
+      tier,
+      criteria,
+      refactor: `refactor${n}`,
+      feature: `feature${n}`,
+      more,
+    })
+  }
+}
+
+interface SliceBuild {
+  readonly tier: RiskTier | undefined
+  readonly criteria: CriteriaSlice | undefined
+  readonly refactor: string
+  readonly feature: string
+  readonly more: boolean
+}
+
+/** A naive pass (judged only with `flagMode` on), then implement and the quality lap. */
+const buildSlice = async (sliceBase: string, build: SliceBuild): Promise<void> => {
+  const seam = await seamBuild(sliceBase, { criteria: build.criteria, refactor: build.refactor })
+  await slice(build.feature, async () => {
     await implement({
       reference: seam.reference,
-      tier,
+      tier: build.tier,
       afterRefactor: seam.refactored,
       naive: seam.land === true ? seam.reference : undefined,
       rebuild: seam.rebuild,
+      slice: build.criteria,
+      base: build.criteria === undefined ? undefined : sliceBase,
+      more: build.more,
     })
     // A feature slice with no code beyond the carried-over tests: the refactor carried the
-    // feature, so the lap covers the whole change.
+    // feature, so the lap covers the whole slice.
     const carried = seam.rebuild?.acceptance?.tests ?? []
     const base =
       seam.refactored === true &&
       !changesSince(seam.base).some((c) => isCode(c.path) && !carried.includes(c.path))
-        ? firstBase
+        ? sliceBase
         : seam.base
-    await tail(settleQuality, { green: true, lensBase: base })
+    // The criteria stay in the tree for the next slice; no quality fix may move them.
+    const guard = build.more ? () => requireCriteriaFrozen(REQUIREMENTS) : undefined
+    await tail(settleQuality, { green: true, lensBase: base, guard, guardRests: false })
   })
 }
 
@@ -103,6 +151,7 @@ export const ordinaryStart = async (): Promise<void> => {
   refusePendingHandOff()
   // Read right after idle, so a bad value refuses the landing that would pin it.
   flagModeOn()
+  sliceCap()
   const stated = statedCriteria(changes(), head())
   await unwind()
   if (changes(FEEDBACK).some((c) => c.status !== "deleted")) {

package/src/workflows/feature/index.ts

@@ -5,6 +5,7 @@ export * from "./criteria.js"
 export * from "./planning.js"
 export * from "./refactor.js"
 export * from "./seam.js"
+export * from "./slicing.js"
 export {
   buildTail,
   type BuildTailOptions,

package/src/workflows/feature/seam.ts

@@ -17,18 +17,24 @@ import {
   removeScript,
   run,
   scope,
-  slice,
+  slice as sliced,
   vars,
   wrote,
   type Change,
   type DiffShapeResult,
   type KeptTip,
 } from "../../flows/index.js"
-import { coder, FEEDBACK, REFACTOR_NOTE, REQUIREMENTS } from "../shared/steps.js"
+import { coder, FEEDBACK, REFACTOR_NOTE, REQUIREMENTS, SLICES } from "../shared/steps.js"
 import * as t from "../shared/text.js"
 import { defaults } from "../shared/vars.js"
 import { green, requireCoverage } from "./coverage.js"
-import { criteriaOf, requireCriteria, requireCriteriaFrozen } from "./criteria.js"
+import {
+  criterionIds,
+  requireCriteria,
+  requireCriteriaFrozen,
+  sliceIds,
+  type CriteriaSlice,
+} from "./criteria.js"
 import {
   COMMENT,
   holdsCallSites,
@@ -54,8 +60,8 @@ export const judgeSeam = (tip: KeptTip): Promise<DiffShapeResult> =>
     exempt: tip.changes.filter((c) => c.status === "added").map((c) => c.path),
   })
 
-export const naivePass = (retry?: t.NaiveRetry): Promise<void> =>
-  t.agentWithSkills("naive", t.naivePassPrompt(retry), {
+export const naivePass = (retry?: t.NaiveRetry, slice?: CriteriaSlice): Promise<void> =>
+  t.agentWithSkills("naive", t.naivePassPrompt(retry, sliceIds(slice)), {
     label: retry === undefined ? "Writing the naive pass" : "Rewriting the naive pass",
     keep: true,
     model: coder(),
@@ -107,8 +113,8 @@ const addedLines = (change: Change): string => {
 const acceptanceTests = (changes: readonly Change[]): readonly Change[] =>
   changes.filter((c) => c.after !== undefined && isCode(c.path) && isTestFile(c.path))
 
-const idsOf = (file: string): string[] =>
-  (criteriaOf(read(file) ?? "") ?? []).map((c) => c.id).filter((id) => id !== "")
+const idsOf = (file: string, slice?: CriteriaSlice): string[] =>
+  criterionIds(read(file) ?? "", slice)
 
 // One rule for both gates, so a naive test carried over verbatim always satisfies the rebuild's.
 const unnamed = (ids: readonly string[], tests: readonly Change[]): string[] => {
@@ -121,9 +127,13 @@ const unnamed = (ids: readonly string[], tests: readonly Change[]): string[] =>
  * test line of the pass names, or a test importing a file the pass added —
  * naive structure a reset and refactor replaces, which the tests must survive.
  */
-export const acceptanceFault = (file: string, tip: KeptTip): string | undefined => {
+export const acceptanceFault = (
+  file: string,
+  tip: KeptTip,
+  slice?: CriteriaSlice,
+): string | undefined => {
   const tests = acceptanceTests(tip.changes)
-  const untested = unnamed(idsOf(file), tests)
+  const untested = unnamed(idsOf(file, slice), tests)
   if (untested.length > 0)
     return `acceptance-tests: no test of the naive pass names ${untested.join(", ")} — write a behaviour-level test for each criterion with its ID in the test or scenario name, e.g. "[${untested[0]}] …"`
   const added = tip.changes
@@ -143,8 +153,8 @@ export const acceptanceFault = (file: string, tip: KeptTip): string | undefined
 }
 
 /** What a rebuild carries over from the naive pass `tip`: the IDs its tests name, and those test files. */
-export const naiveAcceptance = (tip: KeptTip): t.Acceptance => {
-  const ids = idsOf(REQUIREMENTS)
+export const naiveAcceptance = (tip: KeptTip, slice?: CriteriaSlice): t.Acceptance => {
+  const ids = idsOf(REQUIREMENTS, slice)
   const perTest = acceptanceTests(tip.changes).map((c) => {
     const lines = addedLines(c)
     return { path: c.path, ids: ids.filter((id) => named(id, lines)) }
@@ -232,6 +242,12 @@ export interface ImplementOptions {
   readonly naive?: string | undefined
   /** A rebuild after a refactor-first judgment: the note it plugs into, the acceptance tests it must carry. */
   readonly rebuild?: t.Rebuild | undefined
+  /** The criteria this slice builds, when the change has more than one slice. */
+  readonly slice?: CriteriaSlice | undefined
+  /** Where the slice began: the coverage judge reads only the tests changed since. */
+  readonly base?: string | undefined
+  /** Not the last slice: `.gtd/REQUIREMENTS.md` and `.gtd/SLICES.md` stay for the next one. */
+  readonly more?: boolean | undefined
 }
 
 /** Resolves `false` when the tip no longer applies (the failure is in `.gtd/FEEDBACK.md`) or has nothing outside `.gtd/` to apply. */
@@ -270,6 +286,7 @@ export function implement(
           options.afterRefactor,
           flagModeOn(),
           options.rebuild,
+          sliceIds(options.slice),
         ),
         {
           label: "Implementing",
@@ -284,13 +301,20 @@ export function implement(
     await green(
       built && acceptance !== undefined ? () => requireAcceptanceKept(acceptance) : undefined,
     )
-    await requireCoverage()
-    await run("closing", removeScript([REQUIREMENTS, REFACTOR_NOTE]), {
-      label: "Closing out the implementation",
-    })
+    await requireCoverage(options.base, options.slice)
+    await closing(options.more === true)
   })
 }
 
+/** The last slice's closing, for a last slice a steer left with no criterion to build. */
+export const closeOut = (): Promise<void> => scope("implement", () => closing(false))
+
+/** A slice with `more` after it keeps the criteria and the slicing for the next one. */
+const closing = (more: boolean): Promise<void> =>
+  run("closing", removeScript(more ? [REFACTOR_NOTE] : [REQUIREMENTS, REFACTOR_NOTE, SLICES]), {
+    label: "Closing out the implementation",
+  })
+
 interface Decision {
   readonly reference: string
   readonly tip: KeptTip
@@ -340,8 +364,12 @@ interface Vetting {
 }
 
 /** Sends a pass whose tests fall short or run red back (`undefined`: it goes on, an overruled one as it is). */
-const vetted = async (tip: KeptTip, vetting: Vetting): Promise<Verdict | undefined> => {
-  const fault = vetting.waived ? undefined : acceptanceFault(REQUIREMENTS, tip)
+const vetted = async (
+  tip: KeptTip,
+  vetting: Vetting,
+  slice: CriteriaSlice | undefined,
+): Promise<Verdict | undefined> => {
+  const fault = vetting.waived ? undefined : acceptanceFault(REQUIREMENTS, tip, slice)
   if (fault !== undefined) {
     const verdict = await vetting.again({ fault, hash: tip.hash })
     if (verdict.kind !== "overruled") return verdict
@@ -361,15 +389,15 @@ const ruled = async (tip: KeptTip, again: Vetting["again"]): Promise<Decision |
   return next.kind === "overruled" ? { reference: tip.hash, tip } : next
 }
 
-const decide = (): Promise<Decision> =>
+const decide = (slice: CriteriaSlice | undefined): Promise<Decision> =>
   scope("seam", async () => {
     const vetting: Vetting = { again: budget(), waived: false }
     let retry: t.NaiveRetry | undefined
     for (;;) {
-      await naivePass(retry)
+      await naivePass(retry, slice)
       const tip = kept("naive")!
       const outcome =
-        (await vetted(tip, vetting)) ??
+        (await vetted(tip, vetting, slice)) ??
         (flagModeOn() ? await ruled(tip, vetting.again) : { reference: tip.hash, tip })
       if (!("kind" in outcome)) return outcome
       retry = outcome.kind === "retry" ? outcome.retry : undefined
@@ -410,8 +438,14 @@ export const refactorNote = async (
   return note
 }
 
-export const seamBuild = async (base: string): Promise<SeamOutcome> => {
-  const { reference, tip, shape } = await decide()
+export interface SeamSlice {
+  /** Absent for a change built in one slice. */
+  readonly criteria?: CriteriaSlice | undefined
+  readonly refactor?: string | undefined
+}
+
+export const seamBuild = async (base: string, slice: SeamSlice = {}): Promise<SeamOutcome> => {
+  const { reference, tip, shape } = await decide(slice.criteria)
   if (shape === undefined) return { reference, base, land: true }
   if (shape.unreadable.length > 0) {
     await scope("seam", () =>
@@ -421,17 +455,20 @@ export const seamBuild = async (base: string): Promise<SeamOutcome> => {
         acceptClean: true,
       }),
     )
-    return { reference, base, rebuild: { acceptance: naiveAcceptance(tip) } }
+    return { reference, base, rebuild: { acceptance: naiveAcceptance(tip, slice.criteria) } }
   }
   const strays = refactorStrays(shape)
-  if (strays.length === 0) return { reference, base, rebuild: { acceptance: naiveAcceptance(tip) } }
+  if (strays.length === 0)
+    return { reference, base, rebuild: { acceptance: naiveAcceptance(tip, slice.criteria) } }
   const note = await scope("seam", () => refactorNote(reference, strays))
-  const refactored = await slice("refactor", () => reviewedRefactor(shape, { reference, note }))
+  const refactored = await sliced(slice.refactor ?? "refactor", () =>
+    reviewedRefactor(shape, { reference, note }),
+  )
   return {
     reference,
     base: head(),
     refactored,
     // Fixed at `seam.note`, like the package's scope: a later edit of the file reaches neither turn.
-    rebuild: { note, acceptance: naiveAcceptance(tip) },
+    rebuild: { note, acceptance: naiveAcceptance(tip, slice.criteria) },
   }
 }

package/src/workflows/feature/slicing-cap.feature

@@ -0,0 +1,14 @@
+@inmem
+Feature: a bad sliceMaxCriteria refuses the landing that would pin it
+
+  The cap is read right after idle, so a value that is not a positive integer
+  never gets pinned into a process that would refuse every later landing.
+
+  Scenario: a zero cap refuses the idle landing
+    Given the shipped workflows, as gtd install scaffolds them
+    And an environment variable "GTD_SLICEMAXCRITERIA" set to "0"
+    And a file "TODO.md" with:
+      """
+      # Something
+      """
+    Then driving the process is refused with "sliceMaxCriteria must be a positive integer, got \"0\""

package/src/workflows/feature/slicing.feature

@@ -0,0 +1,225 @@
+@inmem
+Feature: a change with more criteria than the cap is built in coarse slices
+
+  After design, criteria within sliceMaxCriteria are one slice, built as
+  before. Above it design.slicing groups them in .gtd/SLICES.md, at most the
+  cap per slice, and each slice runs in order — naive pass, implement, quality
+  lap — from where the previous one landed, as slices feature-1, feature-2, …
+
+  Background:
+    Given the shipped workflows, as gtd install scaffolds them
+    And an environment variable "GTD_QUALITYREVIEWS" set to ""
+    And an environment variable "GTD_FLAGMODE" set to "false"
+    And an environment variable "GTD_SLICEMAXCRITERIA" set to "2"
+    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 a file "TODO.md" with:
+      """
+      # More arithmetic
+
+      subtract, multiply and divide.
+      """
+    And step "unwind" changes nothing
+    And step "start-gate.check" changes nothing
+    And step "design.gate.answer" changes nothing
+    And step "seam.check" changes nothing
+    And step "implement.applying" runs its script
+    And step "implement.health.check" changes nothing
+    And step "implement.closing" runs its script
+
+  Scenario: criteria within the cap are one unnumbered slice with no slicing turn
+    Given step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## Acceptance Criteria
+
+      - AC-1: subtract(a, b) returns a - b.
+      - AC-2: multiply(a, b) returns a * b.
+      """
+    And step "seam.naive" writes "src/calc.test.ts" with:
+      """
+      it("[AC-1] subtracts", () => {})
+      it("[AC-2] multiplies", () => {})
+      """
+    And step "seam.naive" is prompted with "Read `.gtd/REQUIREMENTS.md`"
+    And judge step "implement.coverage" answers:
+      """
+      [{"id":"AC-1","answer":"yes","p":0.9},{"id":"AC-2","answer":"yes","p":0.9}]
+      """
+    When the process is driven
+    Then the process rests at "idle"
+    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.coverage
+      gtd(judge): implement.coverage → implement.closing
+      gtd(check): implement.closing → idle
+      """
+    And the output lines of gtd "slices" start with:
+      """
+      feature
+      """
+    And the output of gtd "slices" does not contain "feature-"
+    And no commit body contains "This slice builds"
+
+  Scenario: criteria above the cap are sliced and built slice by slice
+    Given step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## Acceptance Criteria
+
+      - AC-1: subtract(a, b) returns a - b.
+      - AC-2: multiply(a, b) returns a * b.
+      - AC-3: divide(a, b) returns a / b.
+      """
+    And step "design.slicing" is prompted with "at most 2 per slice"
+    And step "design.slicing" writes ".gtd/SLICES.md" with:
+      """
+      # Slices
+
+      ## Subtract and divide
+
+      - AC-1
+      - AC-3
+
+      ## Multiply
+
+      - AC-2
+      """
+    And step "seam.naive", when prompted with "This slice builds AC-1, AC-3 only", writes "src/sub.test.ts" with:
+      """
+      it("[AC-1] subtracts", () => {})
+      it("[AC-3] divides", () => {})
+      """
+    And step "seam.naive", when prompted with "This slice builds AC-2 only", writes "src/mul.test.ts" with:
+      """
+      it("[AC-2] multiplies", () => {})
+      """
+    And judge step "implement.coverage", when its questions contain "AC-3", answers:
+      """
+      [{"id":"AC-1","answer":"yes","p":0.9},{"id":"AC-3","answer":"yes","p":0.9}]
+      """
+    And judge step "implement.coverage", when its questions contain "AC-2", answers:
+      """
+      [{"id":"AC-2","answer":"yes","p":0.9}]
+      """
+    When the process is driven
+    Then the process rests at "idle"
+    And the commit subjects end with:
+      """
+      gtd(agent): design.triage → design.gate.answer
+      gtd(human): design.gate.answer → design.slicing
+      gtd(agent): design.slicing → 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.coverage
+      gtd(judge): implement.coverage → implement.closing
+      gtd(check): implement.closing → 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.coverage
+      gtd(judge): implement.coverage → implement.closing
+      gtd(check): implement.closing → idle
+      """
+    And the output lines of gtd "slices" start with:
+      """
+      feature-1
+      feature-2
+      """
+    And slice "feature-2" begins where slice "feature-1" ends
+    And "src/sub.test.ts" contains "[AC-3] divides"
+    And "src/mul.test.ts" contains "[AC-2] multiplies"
+    And ".gtd/REQUIREMENTS.md" does not exist
+    And ".gtd/SLICES.md" does not exist
+
+  Scenario: a slice over the cap is refused
+    Given step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## Acceptance Criteria
+
+      - AC-1: subtract(a, b) returns a - b.
+      - AC-2: multiply(a, b) returns a * b.
+      - AC-3: divide(a, b) returns a / b.
+      """
+    And step "design.slicing" writes ".gtd/SLICES.md" with:
+      """
+      # Slices
+
+      ## Everything
+
+      - AC-1
+      - AC-2
+      - AC-3
+      """
+    Then driving the process is refused with "more than 2 criteria in: Everything"
+
+  Scenario: a criterion in no slice is refused
+    Given step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## Acceptance Criteria
+
+      - AC-1: subtract(a, b) returns a - b.
+      - AC-2: multiply(a, b) returns a * b.
+      - AC-3: divide(a, b) returns a / b.
+      """
+    And step "design.slicing" writes ".gtd/SLICES.md" with:
+      """
+      # Slices
+
+      ## Subtract
+
+      - AC-1
+
+      ## Multiply
+
+      - AC-2
+      """
+    Then driving the process is refused with "no slice for: AC-3"
+
+  Scenario: a slicing turn may not change the acceptance criteria
+    Given step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## Acceptance Criteria
+
+      - AC-1: subtract(a, b) returns a - b.
+      - AC-2: multiply(a, b) returns a * b.
+      - AC-3: divide(a, b) returns a / b.
+      """
+    And step "design.slicing" writes ".gtd/REQUIREMENTS.md" with:
+      """
+      # Requirements
+
+      ## Acceptance Criteria
+
+      - AC-1: subtract(a, b) returns a - b.
+      - AC-2: multiply(a, b) returns a * b.
+      """
+    And step "design.slicing" writes ".gtd/SLICES.md" with:
+      """
+      # Slices
+
+      ## Subtract
+
+      - AC-1
+
+      ## Multiply
+
+      - AC-2
+      """
+    Then driving the process is refused with "wrote outside its write access"

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

@@ -0,0 +1,49 @@
+import { describe, expect, it } from "vitest"
+import { sliceCriteria, slicesOf } from "./slicing.js"
+
+describe("slicesOf", () => {
+  it("reads each level-2 heading's ID'd items, in order", () => {
+    expect(
+      slicesOf("# Slices\n\n## Parse\n\n- AC-1: parses\n- AC-3\n\n## Print\n\n- AC-2 prints\n"),
+    ).toEqual([
+      { title: "Parse", ids: ["AC-1", "AC-3"] },
+      { title: "Print", ids: ["AC-2"] },
+    ])
+  })
+
+  it("keeps an item not led by an ID as an empty one, and skips fenced lines", () => {
+    expect(slicesOf("## One\n\n```md\n## Two\n- AC-9\n```\n- AC-10\n- see AC-1\n")).toEqual([
+      { title: "One", ids: ["AC-10", ""] },
+    ])
+  })
+
+  it("ends a slice at any other heading", () => {
+    expect(
+      slicesOf("## One\n\n- AC-1\n\n### Why\n\n- shares the lexer\n\n# Later\n\n- AC-5\n"),
+    ).toEqual([{ title: "One", ids: ["AC-1"] }])
+  })
+
+  it("reads no slice from a file without level-2 headings", () => {
+    expect(slicesOf("# Slices\n\n- AC-1\n")).toEqual([])
+  })
+})
+
+describe("sliceCriteria", () => {
+  const slices = [
+    { title: "A", ids: ["AC-1", "AC-3"] },
+    { title: "B", ids: ["AC-2"] },
+    { title: "C", ids: ["AC-4"] },
+  ]
+
+  it("keeps an earlier slice to its own IDs", () => {
+    expect(sliceCriteria(slices, 1)).toEqual({ only: ["AC-2"] })
+  })
+
+  it("gives the last slice every ID no earlier slice builds", () => {
+    expect(sliceCriteria(slices, 2)).toEqual({ except: ["AC-1", "AC-3", "AC-2"] })
+  })
+
+  it("leaves a single slice unsliced", () => {
+    expect(sliceCriteria([slices[0]!], 0)).toBeUndefined()
+  })
+})