@pmelab/gtd 52.1.0 → 53.0.0

package/src/workflows/feature/seam.ts

@@ -17,36 +17,18 @@ import {
   removeScript,
   run,
   scope,
-  slice as sliced,
-  start,
   vars,
   wrote,
   type Change,
   type DiffShapeResult,
   type KeptTip,
 } from "../../flows/index.js"
-import { continuing, phase, type Handoff, type Phase } from "../shared/continuation.js"
-import {
-  coder,
-  FEEDBACK,
-  HANDOFF,
-  PROTOTYPE,
-  REFACTOR_NOTE,
-  REQUIREMENTS,
-  SLICES,
-} from "../shared/steps.js"
+import { coder, FEEDBACK, PROTOTYPE, REFACTOR_NOTE, REQUIREMENTS } from "../shared/steps.js"
 import * as t from "../shared/text.js"
 import { defaults } from "../shared/vars.js"
 import { green } from "./green.js"
 import { prototypeTest } from "./prototype.js"
-import {
-  criterionIds,
-  requireCriteria,
-  requireCriteriaFrozen,
-  requireCriteriaIfEdited,
-  sliceIds,
-  type CriteriaSlice,
-} from "./criteria.js"
+import { criterionIds, requireCriteria, requireCriteriaFrozen } from "./criteria.js"
 import {
   COMMENT,
   holdsCallSites,
@@ -72,47 +54,14 @@ 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,
-  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",
+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",
     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-]+$/
@@ -158,8 +107,7 @@ 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, slice?: CriteriaSlice): string[] =>
-  criterionIds(read(file) ?? "", slice)
+const idsOf = (file: string): string[] => criterionIds(read(file) ?? "")
 
 // 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[] => {
@@ -172,13 +120,9 @@ 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,
-  slice?: CriteriaSlice,
-): string | undefined => {
+export const acceptanceFault = (file: string, tip: KeptTip): string | undefined => {
   const tests = acceptanceTests(tip.changes)
-  const untested = unnamed(idsOf(file, slice), tests)
+  const untested = unnamed(idsOf(file), 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
@@ -198,8 +142,8 @@ export const acceptanceFault = (
 }
 
 /** What a rebuild carries over from the naive pass `tip`: the IDs its tests name, and those test files. */
-export const naiveAcceptance = (tip: KeptTip, slice?: CriteriaSlice): t.Acceptance => {
-  const ids = idsOf(REQUIREMENTS, slice)
+export const naiveAcceptance = (tip: KeptTip): t.Acceptance => {
+  const ids = idsOf(REQUIREMENTS)
   const perTest = acceptanceTests(tip.changes).map((c) => {
     const lines = addedLines(c)
     return { path: c.path, ids: ids.filter((id) => named(id, lines)) }
@@ -281,18 +225,14 @@ export interface ImplementOptions {
   readonly reference?: string | undefined
   readonly tier?: RiskTier | undefined
   readonly amend?: boolean | undefined
-  /** After a refactor slice, which may already carry the feature: an empty turn completes the step. */
+  /** After a refactor, which may already carry the feature: an empty turn completes the step. */
   readonly afterRefactor?: boolean | undefined
   /** A kept naive tip to apply as the implementation; built fresh only when it no longer applies. */
   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
   /** @deprecated Ignored since the coverage judge is gone. */
   readonly base?: string | undefined
-  /** Not the last slice: `.gtd/REQUIREMENTS.md` and `.gtd/SLICES.md` stay for the next one. */
-  readonly more?: boolean | (() => boolean) | undefined
 }
 
 /** Resolves `false` when the tip no longer applies (the failure is in `.gtd/FEEDBACK.md`) or has nothing outside `.gtd/` to apply. */
@@ -304,54 +244,31 @@ const applied = async (tip: string): Promise<boolean> => {
 }
 
 /** `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
+const settled = (carried: readonly string[]): readonly string[] => {
+  const listed = idsOf(REQUIREMENTS)
   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()))),
-      },
-    }
-  })
+const build = async (options: ImplementOptions): Promise<void> => {
+  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)
+}
 
 export function implement(options?: ImplementOptions): Promise<void>
 /** @deprecated Pass `implement({ reference, tier, amend })`. */
@@ -378,38 +295,21 @@ export const implementing = (options: ImplementOptions): Promise<readonly string
     const built = options.naive === undefined || !(await applied(options.naive))
     if (built) await build(options)
     else requireCriteriaFrozen(REQUIREMENTS)
-    // Only the criteria still listed: a person may narrow them at `implement.oversized`.
+    // Only the criteria the requirements still list.
     if (built && acceptance !== undefined)
-      requireAcceptance({ ...acceptance, ids: settled(acceptance.ids, options.slice) }, since)
+      requireAcceptance({ ...acceptance, ids: settled(acceptance.ids) }, since)
     // Fix turns are held to the carried tests too: deleting a red one must not buy a green suite.
     const keepsTests =
       built && acceptance !== undefined ? () => requireAcceptanceKept(acceptance) : undefined
     await green(keepsTests)
-    await prototypeTest(options.slice, keepsTests)
+    await prototypeTest(keepsTests)
     const ids = criterionIds(read(REQUIREMENTS) ?? "")
-    await closing(moreToBuild(options.more))
+    await run("closing", removeScript([REQUIREMENTS, REFACTOR_NOTE, PROTOTYPE]), {
+      label: "Closing out the implementation",
+    })
     return ids
   })
 
-// Read at closing: a narrowing at `implement.oversized` may have emptied every later slice.
-const moreToBuild = (more: ImplementOptions["more"]): boolean =>
-  typeof more === "function" ? more() : 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, PROTOTYPE]
-        : [REQUIREMENTS, REFACTOR_NOTE, SLICES, HANDOFF, PROTOTYPE],
-    ),
-    { label: "Closing out the implementation" },
-  )
-
 interface Decision {
   readonly reference: string
   readonly tip: KeptTip
@@ -459,12 +359,8 @@ 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,
-  slice: CriteriaSlice | undefined,
-): Promise<Verdict | undefined> => {
-  const fault = vetting.waived ? undefined : acceptanceFault(REQUIREMENTS, tip, slice)
+const vetted = async (tip: KeptTip, vetting: Vetting): Promise<Verdict | undefined> => {
+  const fault = vetting.waived ? undefined : acceptanceFault(REQUIREMENTS, tip)
   if (fault !== undefined) {
     const verdict = await vetting.again({ fault, hash: tip.hash })
     if (verdict.kind !== "overruled") return verdict
@@ -484,15 +380,15 @@ const ruled = async (tip: KeptTip, again: Vetting["again"]): Promise<Decision |
   return next.kind === "overruled" ? { reference: tip.hash, tip } : next
 }
 
-const decide = (slice: CriteriaSlice | undefined): Promise<Decision> =>
+const decide = (): Promise<Decision> =>
   scope("seam", async () => {
     const vetting: Vetting = { again: budget(), waived: false }
-    const naive = phase("naive pass", requireCriteriaIfEdited)
     let retry: t.NaiveRetry | undefined
     for (;;) {
-      const tip = await naiveContinued(retry, slice, naive)
+      await naivePass(retry)
+      const tip = kept("naive")!
       const outcome =
-        (await vetted(tip, vetting, slice)) ??
+        (await vetted(tip, vetting)) ??
         (flagModeOn() ? await ruled(tip, vetting.again) : { reference: tip.hash, tip })
       if (!("kind" in outcome)) return outcome
       retry = outcome.kind === "retry" ? outcome.retry : undefined
@@ -504,7 +400,7 @@ export interface SeamOutcome {
   readonly reference: string
   /** The naive pass lands as it is: no build turn. */
   readonly land?: boolean
-  /** The feature slice's base: HEAD after the refactor on refactor-first, else the caller's base. */
+  /** The feature's base: HEAD after the refactor on refactor-first, else the caller's base. */
   readonly base: string
   readonly refactored?: boolean
   /** Set on refactor-first: what the rebuild carries over from the naive pass (the note only after a refactor). */
@@ -533,14 +429,8 @@ export const refactorNote = async (
   return note
 }
 
-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)
+export const seamBuild = async (base: string): Promise<SeamOutcome> => {
+  const { reference, tip, shape } = await decide()
   if (shape === undefined) return { reference, base, land: true }
   if (shape.unreadable.length > 0) {
     await scope("seam", () =>
@@ -550,20 +440,17 @@ export const seamBuild = async (base: string, slice: SeamSlice = {}): Promise<Se
         acceptClean: true,
       }),
     )
-    return { reference, base, rebuild: { acceptance: naiveAcceptance(tip, slice.criteria) } }
+    return { reference, base, rebuild: { acceptance: naiveAcceptance(tip) } }
   }
   const strays = refactorStrays(shape)
-  if (strays.length === 0)
-    return { reference, base, rebuild: { acceptance: naiveAcceptance(tip, slice.criteria) } }
+  if (strays.length === 0) return { reference, base, rebuild: { acceptance: naiveAcceptance(tip) } }
   const note = await scope("seam", () => refactorNote(reference, strays))
-  const refactored = await sliced(slice.refactor ?? "refactor", () =>
-    reviewedRefactor(shape, { reference, note }),
-  )
+  const refactored = await 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, slice.criteria) },
+    rebuild: { note, acceptance: naiveAcceptance(tip) },
   }
 }

package/src/workflows/index.ts

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

package/src/workflows/shared/lenses.ts

@@ -41,19 +41,6 @@ export interface LensReport {
 
 export const NO_FINDINGS: LensReport = { notes: [], fixed: [], noise: [] }
 
-/** `reports` as one, each finding labelled with the slice it came from, in slice order. */
-export const joinReports = (
-  reports: readonly { readonly slice: string; readonly report: LensReport }[],
-): LensReport => {
-  const tag = <F extends Origin>(slice: string, fs: readonly F[]): F[] =>
-    fs.map((f) => ({ ...f, slice }))
-  return {
-    notes: reports.flatMap((r) => tag(r.slice, r.report.notes)),
-    fixed: reports.flatMap((r) => tag(r.slice, r.report.fixed)),
-    noise: reports.flatMap((r) => tag(r.slice, r.report.noise)),
-  }
-}
-
 const UNTITLED = "Quality findings"
 
 const below = (section: string): string => section.split("\n").slice(1).join("\n").trim()

package/src/workflows/shared/options.test.ts

@@ -8,9 +8,8 @@ const { defaults, envDefaults, feature, fix, review, ShippedOptions } = workflow
 const { flagShipped } = options
 
 describe("the shipped workflow factories", () => {
-  it("take exactly the settings the shipped workflows declare as options, and contextLimit", () => {
-    const settings = Object.keys(ShippedOptions.fields).filter((name) => name !== "contextLimit")
-    expect(settings.sort()).toEqual(
+  it("take exactly the settings the shipped workflows declare as options", () => {
+    expect(Object.keys(ShippedOptions.fields).sort()).toEqual(
       [...Object.keys(defaults), ...Object.keys(envDefaults)]
         .filter((name) => !name.startsWith("flag_"))
         .sort(),
@@ -24,14 +23,6 @@ describe("the shipped workflow factories", () => {
       expect(defaults).toHaveProperty(`flag_${name}`, defaultOn ? "1" : "0")
   })
 
-  it("keep contextLimit out of the settings", () => {
-    const built = configure(feature({ contextLimit: { hard: 0.8 } }))
-    expect(built).toMatchObject({ ok: true })
-    const build = built?.ok === true ? built.build : undefined
-    expect(build?.defaults).not.toHaveProperty("contextLimit")
-    expect(build?.envDefaults).not.toHaveProperty("contextLimit")
-  })
-
   it("declare a seamAllow default a factory option overrides", () => {
     expect(configure(feature({ seamAllow: "docs/**" }))).toMatchObject({
       ok: true,

package/src/workflows/shared/options.ts

@@ -6,7 +6,6 @@ import {
   type WorkflowDoors,
   type WorkflowFactory,
   refuse,
-  scope,
   vars,
 } from "../../flows/index.js"
 import { defaultFlagRegistry, defaults, envDefaults } from "./vars.js"
@@ -23,23 +22,13 @@ export const ShippedOptions = Schema.Struct({
   standardMinP: setting,
   refactorFlagPattern: setting,
   seamAllow: setting,
-  sliceMaxCriteria: setting,
   qualityReviews: setting,
   refactorQualityReviews: setting,
-  continuations: setting,
   prototypeRounds: setting,
-  continuationStall: setting,
   testCommand: setting,
   plannerModel: setting,
   coderModel: setting,
   flagMode: Schema.optionalWith(Schema.Boolean, { exact: true }),
-  contextLimit: Schema.optionalWith(
-    Schema.Struct({
-      soft: Schema.optionalWith(Schema.Number, { exact: true }),
-      hard: Schema.optionalWith(Schema.Number, { exact: true }),
-    }),
-    { exact: true },
-  ),
 })
 
 export type ShippedOptions = Schema.Schema.Encoded<typeof ShippedOptions>
@@ -64,12 +53,6 @@ export const flagModeOn = (): boolean => {
   return value === "true"
 }
 
-// Not a setting: a factory option is known at load, so the scope wraps the
-// whole flow without reading a setting before its first step. The engine
-// refuses limits it cannot use when it reaches an agent step.
-const limited = (flow: Flow, context: ShippedOptions["contextLimit"]): Flow =>
-  context === undefined ? flow : () => scope({ context }, flow)
-
 /** A shipped flow as a factory: its options override the settings it declares, each in its own kind. */
 export const shipped = (
   flow: Flow,
@@ -78,8 +61,8 @@ export const shipped = (
 ): WorkflowFactory<ShippedOptions> =>
   defineWorkflow(
     Schema.standardSchemaV1(ShippedOptions, { onExcessProperty: "error", errors: "all" }),
-    ({ contextLimit, ...options }) => ({
-      flow: limited(flow, contextLimit),
+    (options) => ({
+      flow,
       defaults: over(defaults, options),
       envDefaults: over(envDefaults, options),
       doors,
@@ -97,10 +80,10 @@ export const flagShipped = (
 ): WorkflowFactory<FlagOptions> =>
   defineWorkflow(
     Schema.standardSchemaV1(FlagOptions, { onExcessProperty: "error", errors: "all" }),
-    ({ contextLimit, ...options }) => {
+    (options) => {
       const flagDefaults = { ...defaults, flag: "", flagRegistry: defaultFlagRegistry }
       return {
-        flow: limited(flow, contextLimit),
+        flow,
         defaults: over(flagDefaults, options),
         envDefaults: over(envDefaults, options),
         doors: { [name]: { args: [{ name: "flag" }], vars: ({ flag }) => ({ flag: flag ?? "" }) } },

package/src/workflows/shared/review.test.ts

@@ -779,9 +779,9 @@ describe("BuildTailOptions.lensBase", () => {
   }
 
   it("reaches every quality-lens prompt", async () => {
-    const prompts = await lensPrompts({ lensBase: "SLICE-BASE" })
+    const prompts = await lensPrompts({ lensBase: "LENS-BASE" })
     expect(prompts).toHaveLength(2)
-    for (const prompt of prompts) expect(prompt).toContain("from `SLICE-BASE`")
+    for (const prompt of prompts) expect(prompt).toContain("from `LENS-BASE`")
   })
 
   it("absent, the lens prompts name start()", async () => {
@@ -791,7 +791,7 @@ describe("BuildTailOptions.lensBase", () => {
   })
 
   it("the deprecated positional form runs the same tail as the options form", async () => {
-    const options = { lensBase: "SLICE-BASE" }
+    const options = { lensBase: "LENS-BASE" }
     const modern = await lensPrompts(options)
     const legacy = await lensPrompts(options, () => buildTail(false, "base", true, options))
     expect(legacy).toEqual(modern)

package/src/workflows/shared/steps.ts

@@ -14,8 +14,6 @@ export const REVIEW = ".gtd/REVIEW.md"
 export const REFACTOR = ".gtd/REFACTOR.md"
 export const REFACTOR_NOTE = ".gtd/REFACTOR-NOTE.md"
 export const QUALITY = ".gtd/QUALITY.md"
-export const SLICES = ".gtd/SLICES.md"
-export const HANDOFF = ".gtd/HANDOFF.md"
 export const PROTOTYPE = ".gtd/PROTOTYPE.md"
 
 export const planner = (): string => env.plannerModel ?? ""

package/src/workflows/shared/text.test.ts

@@ -26,7 +26,6 @@ import {
   implementBuildingPrompt,
   implementFixPrompt,
   naivePassPrompt,
-  slicingPrompt,
   refactorBuildingPrompt,
   refactorDroppedRefusal,
   refactorFixPrompt,
@@ -186,10 +185,10 @@ describe("the (no hands-on) tag", () => {
   })
 
   it("names the tagged criteria the testing turn skips, and only when there are any", () => {
-    expect(renderText(() => prototypeTestingPrompt(undefined, ["AC-2", "AC-3"], false))).toContain(
+    expect(renderText(() => prototypeTestingPrompt(["AC-2", "AC-3"], false))).toContain(
       "- Skip AC-2, AC-3: no person can observe them",
     )
-    expect(renderText(() => prototypeTestingPrompt(undefined, [], false))).not.toContain("Skip")
+    expect(renderText(() => prototypeTestingPrompt([], false))).not.toContain("Skip")
   })
 
   it("is kept when the stated criteria are recorded", () => {
@@ -343,7 +342,7 @@ const scratchRepo = () => {
 }
 
 describe("summaryPrompt", () => {
-  it("without a slice prints today's text byte for byte", () => {
+  it("prints the closing-message prompt byte for byte", () => {
     expect(
       summaryPrompt({
         entryCommit: "e1",
@@ -715,67 +714,6 @@ Print the closing message and stop — this writes nothing itself.
     )
   })
 
-  describe("under a slice", () => {
-    const at = (index: number, count: number, extra = {}) => ({
-      ...base,
-      processBase: "sb",
-      processTip: "st",
-      slice: { name: "build", base: "sb", tip: "st", index, count },
-      ...extra,
-    })
-
-    it("names the slice and its place and keeps the range lines", () => {
-      const prompt = summaryPrompt(at(2, 3))
-      expect(prompt).toContain("slice `build`, 2 of 3")
-      expect(prompt).toContain("not the whole process")
-      expect(prompt).toContain("`git log sb..st`")
-      expect(prompt).toContain("`git diff sb st`")
-    })
-
-    it("types the slice by what its diff changes, never by the slice's name", () => {
-      for (const [index, count] of [
-        [1, 2],
-        [2, 2],
-      ] as const) {
-        const prompt = summaryPrompt({
-          ...at(index, count),
-          slice: { ...at(index, count).slice, name: "refactor" },
-        })
-        expect(prompt.replace(/\s+/g, " ")).toContain("never from the slice's name `refactor`")
-        expect(prompt.replace(/\s+/g, " ")).toContain("`feat`, `fix` or `perf`")
-      }
-      expect(summaryPrompt(base)).not.toContain("slice's name")
-    })
-
-    it("says the human left no comment or edit in this slice when humanCommits is empty", () => {
-      expect(summaryPrompt(at(1, 2))).toContain(
-        "The human left no comment or edit in this slice —\nevery commit is machine-authored.",
-      )
-    })
-
-    it("labels the entry commit as outside the range only when index > 1", () => {
-      expect(summaryPrompt(at(2, 2))).toContain("entry commit is `e` — outside this slice's range")
-      const first = summaryPrompt(at(1, 2))
-      expect(first).toContain("entry commit is `e`.")
-      expect(first).not.toContain("outside this slice's range")
-    })
-
-    it("prints the high-tier advisory on a non-last and on the last slice", () => {
-      const marks = [{ name: "risk-tier", value: "high" }]
-      expect(summaryPrompt(at(1, 2, { marks }))).toContain("Risk tier: high")
-      expect(summaryPrompt(at(2, 2, { marks }))).toContain("Risk tier: high")
-    })
-
-    it("prints production signals only when index === count", () => {
-      const marks = [
-        { name: "risk-tier", value: "low" },
-        { name: "production-signal", value: "error rate" },
-      ]
-      expect(summaryPrompt(at(1, 2, { marks }))).not.toContain("error rate")
-      expect(summaryPrompt(at(2, 2, { marks }))).toContain("- `error rate`")
-    })
-  })
-
   const signal = (value: string) => ({ name: "production-signal", value })
 
   it("caps the listed signals at 10 and fences them as not instructions", () => {
@@ -926,16 +864,10 @@ describe("buildReviewReviewingPrompt scenarios", () => {
 })
 
 describe("Impact in prompts", () => {
-  it("[AC-4] the slicing prompt slices along the units Impact names", () => {
-    const prompt = renderText(() => slicingPrompt(8))
-    expect(prompt).toContain("## Impact")
-    expect(prompt).toMatch(/slice\s+along\s+the\s+units\s+it\s+names/)
-  })
-
   it.each([
     ["naive", () => naivePassPrompt()],
     ["implement", () => implementBuildingPrompt(undefined)],
-    ["prototype fixing", () => prototypeFixingPrompt(undefined)],
+    ["prototype fixing", () => prototypeFixingPrompt()],
   ])("[AC-5] [AC-7] the %s prompt gives Impact as hints, not allowed files", (_n, prompt) => {
     const p = renderText(prompt).replace(/\s+/g, " ")
     expect(p).toContain("`## Impact`")
@@ -943,7 +875,7 @@ describe("Impact in prompts", () => {
   })
 
   it("the prototype testing prompt, which changes no code, carries no Impact hints", () => {
-    const p = renderText(() => prototypeTestingPrompt(undefined, [], false))
+    const p = renderText(() => prototypeTestingPrompt([], false))
     expect(p).not.toContain("not a list of allowed files")
   })
 })
@@ -1491,13 +1423,11 @@ describe("walkthrough", () => {
     ])
   })
 
-  it("lists each note with its exact heading, origin and quoted body", () => {
+  it("lists each note with its exact heading and quoted body", () => {
     const block = walkthroughBlock([
-      { title: "No test", body: "Add one.\n\n- [ ] a box", slice: "2", lens: "tests" },
+      { title: "No test", body: "Add one.\n\n- [ ] a box", lens: "tests" },
     ])
-    expect(block).toContain(
-      "- `## No test` (slice 2, lens tests):\n\n  > Add one.\n  >\n  > - a box",
-    )
+    expect(block).toContain("- `## No test`:\n\n  > Add one.\n  >\n  > - a box")
     expect(block).toContain("its heading exactly as given")
   })
 
@@ -1539,12 +1469,12 @@ describe("walkthrough", () => {
   it("appends the fixes and noise, numbered past a title the reviewer took", () => {
     const out = withWalkthrough(review, {
       ...empty,
-      fixed: [{ title: "a", commit: "0123456789", slice: "1" }],
+      fixed: [{ title: "a", commit: "0123456789", lens: "tests" }],
       noise: [{ title: "b", p: 0.9 }],
     })
     expect(
       out.endsWith(
-        "## Fixed automatically (2)\n\n- a (0123456, slice 1)\n\n## Dropped as noise\n\n- b (p=0.9)\n",
+        "## Fixed automatically (2)\n\n- a (0123456)\n\n## Dropped as noise\n\n- b (p=0.9)\n",
       ),
     ).toBe(true)
   })