@pmelab/gtd 52.1.0 → 53.0.0

package/src/wire/WireSchema.test.ts

@@ -9,8 +9,6 @@ import {
   landFields,
   renderBeatJson,
   renderLandJson,
-  renderSlicesJson,
-  slicesDocument,
   statusOf,
   WIRE_SCHEMA,
   type BeatKind,
@@ -118,9 +116,6 @@ const documents: Readonly<Record<string, string>> = {
     }),
   ),
   "judge.json": JUDGE,
-  "slices.json": renderSlicesJson(
-    slicesDocument([{ name: "build", base: "a".repeat(40), tip: "b".repeat(40), closed: true }]),
-  ),
 }
 
 describe(`wire schema ${WIRE_SCHEMA}`, () => {
@@ -144,19 +139,6 @@ describe(`wire schema ${WIRE_SCHEMA}`, () => {
     }
   })
 
-  describe("slicesDocument", () => {
-    it("stamps WIRE_SCHEMA and drops any field beyond the four", () => {
-      const doc = slicesDocument([
-        { name: "n", base: "b", tip: "t", closed: false, extra: 1 } as never,
-      ])
-      expect(doc).toEqual({
-        schema: WIRE_SCHEMA,
-        slices: [{ name: "n", base: "b", tip: "t", closed: false }],
-      })
-      expect(Object.keys(doc.slices[0]!)).toEqual(["name", "base", "tip", "closed"])
-    })
-  })
-
   describe("the shape check", () => {
     const land = JSON.parse(documents["land.json"]!) as Record<string, unknown>
     const { subject, ...rest } = land

package/src/wire/index.ts

@@ -10,5 +10,3 @@ export * from "./Judge.js"
 export { selectPath } from "./Select.js"
 export { resolveSession } from "./Sessions.js"
 export { globMatches } from "./Glob.js"
-export * from "./Slices.js"
-export * from "./ContextLimit.js"

package/src/wire/types.ts

@@ -38,12 +38,6 @@ export interface ApprovalEntry {
   readonly commit: string
 }
 
-/** The context-limit shares a step sets; a driver fills an absent one from its defaults. */
-export interface StepContextLimit {
-  readonly soft?: number
-  readonly hard?: number
-}
-
 export interface RenderedDemandSource {
   readonly state: StateName
   readonly actor: Actor
@@ -57,5 +51,4 @@ export interface RenderedDemandSource {
   readonly judge?: string
   readonly skills?: readonly string[]
   readonly access?: StepAccess
-  readonly context?: StepContextLimit
 }

package/src/workflow/Workflow.ts

@@ -1,12 +1,5 @@
 import type { WorkflowBase, Flow, ScopeAccess, Summary } from "../flows/index.js"
-import type {
-  Actor,
-  ContentKind,
-  StateMode,
-  StateName,
-  StepAccess,
-  StepContextLimit,
-} from "../wire/index.js"
+import type { Actor, ContentKind, StateMode, StateName, StepAccess } from "../wire/index.js"
 
 export type { Actor, ContentKind, StateMode, StateName }
 
@@ -51,7 +44,6 @@ export interface StepDef {
   readonly approve?: boolean
   readonly skills?: readonly string[]
   readonly access?: StepAccess
-  readonly context?: StepContextLimit
 }
 
 /**

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

@@ -139,17 +139,9 @@ describe("statedCriteria", () => {
 describe("criterionIds", () => {
   const requirements = "## Acceptance Criteria\n\n- AC-1: a\n- AC-2: b\n- AC-4: added\n- unnamed\n"
 
-  it("lists every ID'd criterion of an unsliced change", () => {
+  it("lists every ID'd criterion", () => {
     expect(criterionIds(requirements)).toEqual(["AC-1", "AC-2", "AC-4"])
   })
-
-  it("keeps `only` to the IDs the file still lists", () => {
-    expect(criterionIds(requirements, { only: ["AC-1", "AC-3"] })).toEqual(["AC-1"])
-  })
-
-  it("gives `except` every other ID, one added since included", () => {
-    expect(criterionIds(requirements, { except: ["AC-1", "AC-3"] })).toEqual(["AC-2", "AC-4"])
-  })
 })
 
 describe("handsOnIds", () => {
@@ -159,11 +151,6 @@ describe("handsOnIds", () => {
   it("leaves out every criterion tagged (no hands-on)", () => {
     expect(handsOnIds(requirements)).toEqual(["AC-1", "AC-3"])
   })
-
-  it("keeps to the slice", () => {
-    expect(handsOnIds(requirements, { only: ["AC-2", "AC-3"] })).toEqual(["AC-3"])
-    expect(handsOnIds(requirements, { only: ["AC-2", "AC-4"] })).toEqual([])
-  })
 })
 
 describe("unstableIds", () => {

package/src/workflows/feature/criteria.ts

@@ -79,37 +79,16 @@ export const criteriaOf = (text: string): readonly Criterion[] | undefined =>
     return id === null ? { id: "", text: item } : criterion(id)
   })
 
-/**
- * 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),
-    )
+/** The ID'd criteria of `text`. */
+export const criterionIds = (text: string): string[] =>
+  (criteriaOf(text) ?? []).map((c) => c.id).filter((id) => id !== "")
 
-/** The ID'd criteria of `text` (`slice`'s when given) a person can try by hand: none tagged `(no hands-on)`. */
-export const handsOnIds = (text: string, slice?: CriteriaSlice): string[] => {
+/** The ID'd criteria of `text` a person can try by hand: none tagged `(no hands-on)`. */
+export const handsOnIds = (text: string): string[] => {
   const tagged = (criteriaOf(text) ?? []).filter((c) => c.noHandsOn).map((c) => c.id)
-  return criterionIds(text, slice).filter((id) => !tagged.includes(id))
+  return criterionIds(text).filter((id) => !tagged.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))
@@ -292,14 +271,3 @@ export const skipDesign = (stated: StatedCriteria | undefined): Promise<boolean>
         await impact()
         return true
       })
-
-/** After a gate that invites narrowing the requirements: an edit must leave valid criteria. */
-export const requireCriteriaIfEdited = (): void => {
-  const change = changes().get(REQUIREMENTS)
-  if (change === undefined) return
-  if (change.status === "deleted")
-    refuse(
-      `gtd land: criteria-missing: ${REQUIREMENTS} must stay — narrow its criteria, never delete it`,
-    )
-  requireCriteria(REQUIREMENTS)
-}

package/src/workflows/feature/feature.ts

@@ -6,44 +6,36 @@ import {
   read,
   revertScript,
   run,
-  slice,
   start,
 } from "../../flows/index.js"
 import { gate } from "../shared/health.js"
-import { joinReports, type LensReport } from "../shared/lenses.js"
 import { flagModeOn, shipped } from "../shared/options.js"
 import { FEEDBACK, REQUIREMENTS } from "../shared/steps.js"
 import { refusePendingHandOff, tail } from "../shared/tail.js"
 import * as t from "../shared/text.js"
 import {
   criterionIds,
-  requireCriteriaFrozen,
   requireStableIds,
   type StableIds,
   skipDesign,
-  sliceIds,
   statedCriteria,
-  type CriteriaSlice,
   type StatedCriteria,
 } from "./criteria.js"
 import { design } from "./planning.js"
 import { buildTail, humanReview, isCode, reUnwind, type ReviewOutcome } from "../shared/review.js"
 import { prototypeRounds } from "./prototype.js"
 import { implement, implementing, seamBuild } from "./seam.js"
-import { sliceCap, sliceCriteria, slicing } from "./slicing.js"
-import { recordRisk, riskTierOn, type RiskTier } from "./tier.js"
+import { recordRisk, riskTierOn } 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 → 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 → a
-// hands-on test of every criterion, fixed and re-tested → the
-// triaged quality lap, whose leftovers are carried on → after the last slice,
-// a reviewer's walkthrough of the whole change, every slice's findings
-// among its chunks, for the human, which
-// signs off (the episode ends back at `idle`) or sends a design → implement
-// lap.
+// 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 → a hands-on test of every criterion,
+// fixed and re-tested → the triaged quality lap, whose leftovers are carried
+// on → a reviewer's walkthrough of the whole change, its findings among its
+// chunks, for the human, which signs off (the episode ends back at `idle`) or
+// sends a design → implement lap.
 
 /** Revert the sketch that started the process out of the working tree; its intent survives in history. */
 export const unwind = (): Promise<void> => {
@@ -56,36 +48,32 @@ export const unwind = (): Promise<void> => {
 export { reUnwind }
 
 /**
- * The slices `design.slicing` grouped the criteria into, each built in turn
- * from where the previous one landed; design must have run since `firstBase`.
+ * A naive pass (judged only with `flagMode` on), then implement and the
+ * quality lap, then the review; design must have run since `firstBase`.
  */
 export const buildFeature = async (firstBase: string): Promise<void> => {
   const tier = riskTierOn() ? recordRisk() : undefined
-  const slices = await slicing()
-  // Every ID handed out, gathered before a later narrowing can drop one: none is ever reused.
+  // Every ID handed out, gathered before a later edit can drop one: none is ever reused.
   const handedOut = new Set(listedIds())
-  // A single slice keeps the unnumbered names and builds against every criterion.
-  const one = slices.length === 1
-  // A steer may delete every criterion of a later slice: there is nothing to build there.
-  const built = (i: number): boolean => sliceIds(sliceCriteria(slices, i))?.length !== 0
-  const reports: { slice: string; report: LensReport }[] = []
-  for (const i of slices.keys()) {
-    if (!built(i)) continue
-    const n = one ? "" : `-${i + 1}`
-    await buildSlice(i === 0 ? firstBase : head(), {
-      number: `${i + 1}`,
-      tier,
-      criteria: sliceCriteria(slices, i),
-      refactor: `refactor${n}`,
-      feature: `feature${n}`,
-      // A steer or a narrowing may empty every later slice.
-      more: () => slices.some((_, j) => j > i && built(j)),
-      // Every slice but the one is built unreviewed, so the review covers them all.
-      reviewBase: one ? undefined : firstBase,
-      handedOut,
-      laps: reports,
-    })
-  }
+  const seam = await seamBuild(firstBase)
+  const used = gather(handedOut)
+  const closed = await implementing({
+    reference: seam.reference,
+    tier,
+    afterRefactor: seam.refactored,
+    naive: seam.land === true ? seam.reference : undefined,
+    rebuild: seam.rebuild,
+  })
+  // A feature with no code beyond the carried-over tests: the refactor carried
+  // it, so the lap covers the whole change.
+  const carried = seam.rebuild?.acceptance?.tests ?? []
+  const base =
+    seam.refactored === true &&
+    !changesSince(seam.base).some((c) => isCode(c.path) && !carried.includes(c.path))
+      ? firstBase
+      : seam.base
+  const outcome = await reviewedTail(base, base)
+  await featureFeedback(outcome, base, { closed, used })
 }
 
 const listedIds = (): readonly string[] => criterionIds(read(REQUIREMENTS) ?? "")
@@ -95,85 +83,14 @@ const gather = (handedOut: Set<string>): readonly string[] => {
   return [...handedOut]
 }
 
-interface SliceBuild {
-  /** The slice's number, from 1. */
-  readonly number: string
-  readonly tier: RiskTier | undefined
-  readonly criteria: CriteriaSlice | undefined
-  readonly refactor: string
-  readonly feature: string
-  readonly more: () => boolean
-  /** Absent: the slice's own base. */
-  readonly reviewBase?: string | undefined
-  /** Every criterion ID handed out so far; the slice adds those a steer adds. */
-  readonly handedOut: Set<string>
-  /** Each earlier slice's lap report, by slice number, for the review after the last one. */
-  readonly laps: { slice: string; report: LensReport }[]
-}
-
-/** A naive pass (judged only with `flagMode` on), then implement and the quality lap; after the last slice, the review. */
-const buildSlice = async (sliceBase: string, build: SliceBuild): Promise<void> => {
-  const seam = await seamBuild(sliceBase, { criteria: build.criteria, refactor: build.refactor })
-  const used = gather(build.handedOut)
-  await slice(build.feature, async () => {
-    const closed = await implementing({
-      reference: seam.reference,
-      tier: build.tier,
-      afterRefactor: seam.refactored,
-      naive: seam.land === true ? seam.reference : undefined,
-      rebuild: seam.rebuild,
-      slice: build.criteria,
-      more: build.more,
-    })
-    // Closing kept the criteria exactly when there is more to build, so this reads as it did.
-    const 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 slice.
-    const carried = seam.rebuild?.acceptance?.tests ?? []
-    const base =
-      seam.refactored === true &&
-      !changesSince(seam.base).some((c) => isCode(c.path) && !carried.includes(c.path))
-        ? sliceBase
-        : seam.base
-    if (more) {
-      // The criteria stay in the tree for the next slice; no quality fix may move them.
-      const guard = () => requireCriteriaFrozen(REQUIREMENTS)
-      // No gate between slices: what the lap left waits for the review after the last one.
-      const report = await tail(async (_, report) => report, {
-        green: true,
-        lensBase: base,
-        guard,
-        guardRests: false,
-      })
-      build.laps.push({ slice: build.number, report })
-      return
-    }
-    const reviewBase = build.reviewBase ?? base
-    const outcome = await reviewedTail(reviewBase, base, { slice: build.number, laps: build.laps })
-    await featureFeedback(outcome, base, { closed, used })
-  })
-}
-
-/**
- * The quality lap of slice `last.slice`, then a reviewer's walkthrough since
- * `base` for the human, carrying what earlier slices' `laps` left too.
- */
+/** The quality lap, then a reviewer's walkthrough since `base` for the human. */
 const reviewedTail = (
   base: string,
   lensBase: string,
-  last: { readonly slice: string; readonly laps: SliceBuild["laps"] } = { slice: "", laps: [] },
   lap: "first" | "feedback" = "first",
 ): Promise<ReviewOutcome> =>
   tail(
-    (escalations, report) =>
-      humanReview(base, escalations, {
-        report:
-          last.laps.length === 0
-            ? report
-            : joinReports([...last.laps, { slice: last.slice, report }]),
-        walkthrough: true,
-        lap,
-      }),
+    (escalations, report) => humanReview(base, escalations, { report, walkthrough: true, lap }),
     { green: true, lensBase },
   )
 
@@ -197,7 +114,7 @@ const featureFeedback = async (
     })
     const tier = riskTierOn() ? recordRisk() : undefined
     closed = await implementing({ tier, amend: true })
-    outcome = await reviewedTail(outcome.base, lensBase, undefined, "feedback")
+    outcome = await reviewedTail(outcome.base, lensBase, "feedback")
   }
 }
 
@@ -209,7 +126,7 @@ export const planAndBuild = async (firstBase: string, stated?: StatedCriteria):
 }
 
 // seam.naive / seam.judge never run here: a re-plan's seam is built unjudged and unrefactored.
-/** After a tail that skipped planning: stop on sign-off, re-plan on feedback. Opens no slice: slices cannot nest. */
+/** After a tail that skipped planning: stop on sign-off, re-plan on feedback. */
 export const afterTail = async (first: ReviewOutcome): Promise<void> => {
   let outcome = first
   while (outcome.verdict === "feedback") {
@@ -227,7 +144,6 @@ export const ordinaryStart = async (): Promise<void> => {
   refusePendingHandOff()
   // Read right after idle, so a bad value refuses the landing that would pin it.
   flagModeOn()
-  sliceCap()
   prototypeRounds()
   const stated = statedCriteria(changes(), head())
   await unwind()

package/src/workflows/feature/hands-on-skip.feature

@@ -7,14 +7,13 @@ Feature: the hands-on test tries only the criteria a person can observe
   per untagged criterion, whether a person can observe it by using the
   software; a tagged one is never asked about. Every ID it does not answer
   `no` reaches implement.prototype.testing, which must report each once and
-  needs no chunk for the rest. A slice with no such criterion is not tested by hand, and
-  nothing rests to say so.
+  needs no chunk for the rest. A change with no such criterion is not tested by
+  hand, and nothing rests to say so.
 
   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
@@ -275,73 +274,6 @@ Feature: the hands-on test tries only the criteria a person can observe
       gtd(check): implement.closing → build.review.reviewing
       """
 
-  Scenario: each slice's hands-on test judges its own criteria afresh
-    Given step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
-      """
-      # Requirements
-
-      ## Impact
-
-      - the greeting module
-
-      ## Acceptance Criteria
-
-      - AC-1: subtract(a, b) returns a - b.
-      - AC-2 (no hands-on): the build prompt names subtract.
-      - AC-3: the review prompt names subtract.
-      """
-    And step "design.slicing" writes ".gtd/SLICES.md" with:
-      """
-      # Slices
-
-      ## Prompts
-
-      - AC-2
-      - AC-3
-
-      ## Subtract
-
-      - AC-1
-      """
-    And step "seam.naive", when prompted with "This slice builds AC-2, AC-3 only", writes "src/prompts.test.ts" with:
-      """
-      it("[AC-2] names subtract in the build", () => {})
-      it("[AC-3] names subtract in the review", () => {})
-      """
-    And step "seam.naive", when prompted with "This slice builds AC-1 only", writes "src/calc.test.ts" with:
-      """
-      it("[AC-1] subtracts", () => {})
-      """
-    And judge step "implement.prototype.observable", when its questions contain "criterion AC-3 describes", answers:
-      """
-      [{"id":"AC-3","answer":"no","p":0.9}]
-      """
-    And judge step "implement.prototype.observable", when its questions contain "criterion AC-1 describes", answers:
-      """
-      [{"id":"AC-1","answer":"yes","p":0.9}]
-      """
-    And step "implement.prototype.testing" writes ".gtd/PROTOTYPE.md" with:
-      """
-      ## AC-1: pass
-
-      Printed 2.
-      """
-    When the process is driven
-    Then the process rests at "build.review.reviewing"
-    And the commit subjects end with:
-      """
-      gtd(check): implement.health.check → implement.prototype.observable
-      gtd(judge): implement.prototype.observable → 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.prototype.observable
-      gtd(judge): implement.prototype.observable → implement.prototype.testing
-      gtd(agent): implement.prototype.testing → implement.closing
-      gtd(check): implement.closing → build.review.reviewing
-      """
-
   Scenario: the tag is frozen once design is settled
     Given step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
       """

package/src/workflows/feature/index.ts

@@ -5,7 +5,6 @@ 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/one-step-land.feature

@@ -87,8 +87,4 @@ Feature: a naive pass the judge rules land is itself the implementation
     And the commit "gtd(agent): seam.naive → seam.check" has a body containing "Gtd-Kept:"
     And the commit "gtd(judge): seam.judge → implement.applying" 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/prototype-rounds.feature

@@ -1,7 +1,7 @@
 @inmem
 Feature: past its round cap the hands-on test rests at a person's gate
 
-  `prototypeRounds` caps the fix turns a slice's hands-on test gets. Once they
+  `prototypeRounds` caps the fix turns the hands-on test gets. Once they
   are spent and the report still has open items, the process rests at
   implement.prototype.open naming them; a person's fix there is tested again
   with a fresh budget.

package/src/workflows/feature/prototype.feature

@@ -3,10 +3,10 @@ Feature: every observable criterion is tested by hand before the quality lap
 
   Once the suite is green, implement.prototype.observable judges which
   criteria a person can observe, and implement.prototype.testing uses the
-  slice the way a person would and writes .gtd/PROTOTYPE.md, one chunk per
+  change the way a person would and writes .gtd/PROTOTYPE.md, one chunk per
   such criterion headed `## AC-<n>: pass|fail|blocked`, plus one per problem
   found beside them. A failure goes to implement.prototype.fix.fixing and is tested again; only a clean
-  report closes the slice. Past `prototypeRounds` fix rounds, or with nothing a
+  report closes the test. Past `prototypeRounds` fix rounds, or with nothing a
   fixer can take, a person decides at implement.prototype.open.
 
   Background:
@@ -67,7 +67,7 @@ Feature: every observable criterion is tested by hand before the quality lap
     And the resting step's content contains "against the user's real data or this working tree"
     And the resting step's content contains "`## AC-<n>: pass`"
 
-  Scenario: a clean report closes the slice and moves on to the quality lap
+  Scenario: a clean report closes the test and moves on to the quality lap
     Given step "implement.prototype.testing" writes ".gtd/PROTOTYPE.md" with:
       """
       # Prototype test

package/src/workflows/feature/prototype.ts

@@ -5,14 +5,7 @@ import * as t from "../shared/text.js"
 import { defaults } from "../shared/vars.js"
 import type { Guard } from "../shared/health.js"
 import { green } from "./green.js"
-import {
-  criteriaOf,
-  criterionIds,
-  handsOnIds,
-  requireCriteriaFrozen,
-  sliceIds,
-  type CriteriaSlice,
-} from "./criteria.js"
+import { criteriaOf, criterionIds, handsOnIds, requireCriteriaFrozen } from "./criteria.js"
 
 /** Only a `no` at this or above skips a criterion: no verdict, or an unsure one, sends it to the hands-on test. */
 const UNOBSERVABLE_MIN_P = 0.5
@@ -102,12 +95,12 @@ const requireReport = (
 }
 
 /**
- * The slice's criteria a person can observe by using the change, by the
- * judge: those tagged `(no hands-on)` are never asked about.
+ * The criteria a person can observe by using the change, by the judge: those
+ * tagged `(no hands-on)` are never asked about.
  */
-const observable = async (slice: CriteriaSlice | undefined): Promise<string[]> => {
+const observable = async (): Promise<string[]> => {
   const requirements = read(REQUIREMENTS) ?? ""
-  const own = handsOnIds(requirements, slice)
+  const own = handsOnIds(requirements)
   const criteria = (criteriaOf(requirements) ?? []).filter((c) => own.includes(c.id))
   if (criteria.length === 0) return []
   const { answers } = await judge("observable", {
@@ -122,13 +115,12 @@ const observable = async (slice: CriteriaSlice | undefined): Promise<string[]> =
 const frozen = (): void => requireCriteriaFrozen(REQUIREMENTS)
 
 const testing = async (
-  slice: CriteriaSlice | undefined,
   ids: readonly string[],
   retest: boolean,
 ): Promise<ReturnType<typeof requireReport>> => {
-  const skipped = criterionIds(read(REQUIREMENTS) ?? "", slice).filter((id) => !ids.includes(id))
-  await t.agentWithSkills("testing", t.prototypeTestingPrompt(sliceIds(slice), skipped, retest), {
-    label: retest ? "Re-testing the slice by hand" : "Testing the slice by hand",
+  const skipped = criterionIds(read(REQUIREMENTS) ?? "").filter((id) => !ids.includes(id))
+  await t.agentWithSkills("testing", t.prototypeTestingPrompt(skipped, retest), {
+    label: retest ? "Re-testing the change by hand" : "Testing the change by hand",
     file: PROTOTYPE,
     model: coder(),
     system: t.testerSystem(),
@@ -138,9 +130,9 @@ const testing = async (
   return requireReport(ids, retest)
 }
 
-const fixing = async (slice: CriteriaSlice | undefined, guard?: Guard): Promise<void> => {
+const fixing = async (guard?: Guard): Promise<void> => {
   await scope("fix", () =>
-    t.agentWithSkills("fixing", t.prototypeFixingPrompt(sliceIds(slice)), {
+    t.agentWithSkills("fixing", t.prototypeFixingPrompt(), {
       label: "Fixing what the hands-on test found",
       file: PROTOTYPE,
       model: coder(),
@@ -166,25 +158,22 @@ const askPerson = async (name: string, message: string, label: string): Promise<
 }
 
 /**
- * Use the slice by hand: a testing turn reports on every criterion a person
- * can observe, a fix turn takes each failure, and the slice is tested again —
+ * Use the change by hand: a testing turn reports on every criterion a person
+ * can observe, a fix turn takes each failure, and the change is tested again —
  * until the report is clean, or `prototypeRounds` fixes are spent and a person
- * decides. A slice with no such criterion is not tested by hand. `guard` holds
- * every fix turn, as it holds the implementation's.
+ * decides. A change with no such criterion is not tested by hand. `guard`
+ * holds every fix turn, as it holds the implementation's.
  */
-export const prototypeTest = async (
-  slice: CriteriaSlice | undefined,
-  guard?: Guard,
-): Promise<void> => {
+export const prototypeTest = async (guard?: Guard): Promise<void> => {
   const cap = prototypeRounds()
   if (cap === 0) return
   await scope("prototype", async () => {
-    const ids = await observable(slice)
+    const ids = await observable()
     if (ids.length === 0) return
     let fixes = 0
     let retest = false
     for (;;) {
-      const { unguided, open } = await testing(slice, ids, retest)
+      const { unguided, open } = await testing(ids, retest)
       retest = !unguided
       if (unguided) {
         const instructed = await askPerson(
@@ -196,7 +185,7 @@ export const prototypeTest = async (
       } else if (open.length === 0) return
       else if (fixes < cap && open.some((i) => i.verdict === "fail")) {
         fixes++
-        await fixing(slice, guard)
+        await fixing(guard)
       } else {
         const changed = await askPerson(
           "open",