@pmelab/gtd 37.0.0 → 38.1.0

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/refactor.ts

@@ -15,8 +15,9 @@ import {
 } from "../../flows/index.js"
 import { lensEntriesOf } from "../../workflow-kit/index.js"
 import { markFenced } from "../shared/fences.js"
+import { continuing, phase, type Phase } from "../shared/continuation.js"
 import { healthy, type Guard } from "../shared/health.js"
-import { coder, FEEDBACK, REFACTOR } from "../shared/steps.js"
+import { coder, FEEDBACK, HANDOFF, 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 "./review.js"
@@ -263,7 +264,12 @@ const guardOf =
   }
 
 /** 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 refactorLap = async (
+  p: Plan,
+  guard: Guard,
+  refactor: Phase,
+  feedback?: string,
+): Promise<void> => {
   const { pattern, strays, reference, note } = p
   await run(
     "deriving",
@@ -276,32 +282,59 @@ const refactorLap = async (p: Plan, guard: Guard, feedback?: string): Promise<vo
     ]),
     { 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 reached = new Set<string>()
+  // Each snapshot is greened before its continuation: every sub-step keeps the old suite green.
+  await continuing(refactor, async (from, fresh) => {
+    await fresh(() =>
+      t.agentWithSkills(
+        "building",
+        t.refactorBuildingPrompt({
+          pkg: REFACTOR_PACKAGE,
+          strays,
+          pattern,
+          reference,
+          feedback: feedback !== undefined,
+          note: note !== undefined,
+          from,
+        }),
+        {
+          label: from === undefined ? "Refactoring" : "Continuing the refactor",
+          model: coder(),
+          system: t.builderSystem(),
+        },
+      ),
+    )
+    // Committed by the snapshot, so a turn stopped again may leave it as it was: present means stopped.
+    const left = read(HANDOFF)
+    guard()
+    const snapshot = head()
+    // The building turns' own changes only: a fix turn reaching a path is not the refactor reaching it.
+    for (const c of changes()) reached.add(c.path)
+    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) },
+    )
+    if (left === undefined) return { result: undefined }
+    return {
+      result: undefined,
+      handoff: {
+        snapshot,
+        note: left.trim(),
+        open: strays.filter((path) => !reached.has(path)),
+      },
+    }
+  })
+  await run("closing", removeScript([REFACTOR_PACKAGE, HANDOFF]), {
+    label: "Closing out the refactor",
+  })
 }
 
 const strayAccess = (strays: readonly string[]) => ({
@@ -315,7 +348,7 @@ export const refactorFirst = async (
   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()))
+    await refactorLap(p, guardOf(p, head()), phase("refactor"))
     return true
   })
 }
@@ -342,9 +375,10 @@ export const reviewedRefactor = async (
         "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,
     }
+    const refactor = phase("refactor")
     let collected: string | undefined
     for (;;) {
-      await refactorLap(p, guard, collected)
+      await refactorLap(p, guard, refactor, collected)
       // A person's edit at an escalation rest is never refused, as in the lap.
       const outcome = await buildTail(entry, {
         green: true,

package/src/workflows/feature/seam.ts

@@ -17,18 +17,27 @@ import {
   removeScript,
   run,
   scope,
-  slice,
+  slice as sliced,
+  start,
   vars,
   wrote,
   type Change,
   type DiffShapeResult,
   type KeptTip,
 } from "../../flows/index.js"
-import { coder, FEEDBACK, REFACTOR_NOTE, REQUIREMENTS } from "../shared/steps.js"
+import { continuing, phase, type Handoff, type Phase } from "../shared/continuation.js"
+import { coder, FEEDBACK, HANDOFF, 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,
+  requireCriteriaIfEdited,
+  sliceIds,
+  type CriteriaSlice,
+} from "./criteria.js"
 import {
   COMMENT,
   holdsCallSites,
@@ -54,14 +63,47 @@ 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), {
-    label: retry === undefined ? "Writing the naive pass" : "Rewriting the naive pass",
+export const naivePass = (
+  retry?: t.NaiveRetry,
+  slice?: CriteriaSlice,
+  from?: Handoff,
+): Promise<void> =>
+  t.agentWithSkills("naive", t.naivePassPrompt(retry, sliceIds(slice), from), {
+    label:
+      from !== undefined
+        ? "Continuing the naive pass"
+        : retry === undefined
+          ? "Writing the naive pass"
+          : "Rewriting the naive pass",
     keep: true,
     model: coder(),
     system: t.builderSystem(),
   })
 
+const handoffOf = (tip: KeptTip, slice: CriteriaSlice | undefined): Handoff | undefined => {
+  const note = tip.changes.find((c) => c.path === HANDOFF && c.after !== undefined)
+  if (note === undefined) return undefined
+  return {
+    snapshot: tip.hash,
+    note: note.after!.trim(),
+    open: unnamed(idsOf(REQUIREMENTS, slice), acceptanceTests(tip.changes)),
+  }
+}
+
+/** A naive pass, continued until a pass ends without a handoff note: the snapshot is its kept tip. */
+const naiveContinued = (
+  retry: t.NaiveRetry | undefined,
+  slice: CriteriaSlice | undefined,
+  naive: Phase,
+) =>
+  continuing(naive, async (from, fresh) => {
+    const tip = await fresh(async () => {
+      await naivePass(retry, slice, from)
+      return kept("naive")!
+    })
+    return { result: tip, handoff: handoffOf(tip, slice) }
+  })
+
 // Only a string an import, `require` or `mock` call takes: a URL route or path-like data is not one.
 const IMPORTED = /(?:\bfrom|\bimport|\brequire\s*\(|\bmock\s*\()\s*\(?\s*(["'`])([^"'`\n]+)\1/g
 const EXTENSION = /\.[\w-]+$/
@@ -107,8 +149,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 +163,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 +189,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 +278,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. */
@@ -242,6 +294,56 @@ const applied = async (tip: string): Promise<boolean> => {
   return !wrote(FEEDBACK) && codeChanges().length > 0
 }
 
+/** `carried` limited to the criteria `.gtd/REQUIREMENTS.md` lists now; a file listing none narrows nothing. */
+const settled = (
+  carried: readonly string[] | undefined,
+  slice: CriteriaSlice | undefined,
+): readonly string[] => {
+  const listed = idsOf(REQUIREMENTS, slice)
+  if (carried === undefined) return listed
+  return listed.length === 0 ? carried : carried.filter((id) => listed.includes(id))
+}
+
+// A snapshot lands on the branch as it is; the health loop greens the whole build after.
+// Open IDs count every test line since the process start, so an amend lap's earlier tests close theirs.
+const build = (options: ImplementOptions): Promise<void> =>
+  continuing(phase("build", requireCriteriaIfEdited), async (from, fresh) => {
+    await fresh(() =>
+      t.agentWithSkills(
+        "building",
+        t.implementBuildingPrompt(
+          options.reference,
+          options.tier,
+          options.amend,
+          options.afterRefactor,
+          flagModeOn(),
+          options.rebuild,
+          sliceIds(options.slice),
+          from,
+        ),
+        {
+          label: from === undefined ? "Implementing" : "Continuing the implementation",
+          model: coder(),
+          system: t.builderSystem(),
+          ...(options.afterRefactor === true ? { allowEmpty: true } : {}),
+        },
+      ),
+    )
+    requireCriteriaFrozen(REQUIREMENTS)
+    // Committed by the snapshot, so a turn stopped again may leave it as it was: present means stopped.
+    const note = read(HANDOFF)
+    if (note === undefined) return { result: undefined }
+    const ids = settled(options.rebuild?.acceptance?.ids, options.slice)
+    return {
+      result: undefined,
+      handoff: {
+        snapshot: head(),
+        note: note.trim(),
+        open: unnamed(ids, acceptanceTests(changesSince(start()))),
+      },
+    }
+  })
+
 export function implement(options?: ImplementOptions): Promise<void>
 /** @deprecated Pass `implement({ reference, tier, amend })`. */
 export function implement(
@@ -260,37 +362,31 @@ export function implement(
     const since = head()
     const acceptance = options.rebuild?.acceptance
     const built = options.naive === undefined || !(await applied(options.naive))
-    if (built)
-      await t.agentWithSkills(
-        "building",
-        t.implementBuildingPrompt(
-          options.reference,
-          options.tier,
-          options.amend,
-          options.afterRefactor,
-          flagModeOn(),
-          options.rebuild,
-        ),
-        {
-          label: "Implementing",
-          model: coder(),
-          system: t.builderSystem(),
-          ...(options.afterRefactor === true ? { allowEmpty: true } : {}),
-        },
-      )
-    requireCriteriaFrozen(REQUIREMENTS)
-    if (built && acceptance !== undefined) requireAcceptance(acceptance, since)
+    if (built) await build(options)
+    else requireCriteriaFrozen(REQUIREMENTS)
+    // Only the criteria still listed: a person may narrow them at `implement.oversized`.
+    if (built && acceptance !== undefined)
+      requireAcceptance({ ...acceptance, ids: settled(acceptance.ids, options.slice) }, since)
     // Fix turns are held to the carried tests too: deleting a red one must not buy a green suite.
     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, HANDOFF] : [REQUIREMENTS, REFACTOR_NOTE, SLICES, HANDOFF]),
+    { label: "Closing out the implementation" },
+  )
+
 interface Decision {
   readonly reference: string
   readonly tip: KeptTip
@@ -340,8 +436,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 +461,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 }
+    const naive = phase("naive pass", requireCriteriaIfEdited)
     let retry: t.NaiveRetry | undefined
     for (;;) {
-      await naivePass(retry)
-      const tip = kept("naive")!
+      const tip = await naiveContinued(retry, slice, 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 +510,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 +527,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\""