@pmelab/gtd 52.1.0 → 54.0.0

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",

package/src/workflows/feature/refactor-absorbs.feature

@@ -3,10 +3,10 @@
 Feature: a refactor that carried the whole feature still gets a quality lap over all of it
 
   With GTD_FLAG_RISK_TIER off, a refactor-first
-  refactor can land everything the requirements ask for. The feature slice's
+  refactor can land everything the requirements ask for. The feature's
   implement turn then has only the naive pass's acceptance tests to carry
-  over, and with no code but tests changed since the refactor the feature
-  slice's quality lap covers the whole change, refactor included.
+  over, and with no code but tests changed since the refactor the feature's
+  quality lap covers the whole change, refactor included.
 
   Background:
     Given the shipped workflows, as gtd install scaffolds them
@@ -132,8 +132,3 @@ Feature: a refactor that carried the whole feature still gets a quality lap over
       gtd(check): implement.closing → build.quality.correctness.reviewing
       gtd(agent): build.quality.correctness.reviewing → build.review.reviewing
       """
-    And the output lines of gtd "slices" start with:
-      """
-      refactor 
-      feature 
-      """

package/src/workflows/feature/refactor-first.feature

@@ -160,9 +160,4 @@ Feature: a refactor-first judgment walks one fixed path to the review gate
     And the commit "gtd(agent): seam.naive → seam.check" has a body containing "Gtd-Kept:"
     And the commit "gtd(judge): seam.judge → seam.note" has a body containing "\"answer\":\"refactor-first\""
     And no commit body contains "Gtd-Approved:"
-    And the output lines of gtd "slices" start with:
-      """
-      refactor 
-      feature 
-      """
     And no commit body contains "Gtd-Workflow:"

package/src/workflows/feature/refactor-rebuild.feature

@@ -197,7 +197,6 @@ Feature: refactor-first writes a refactor note, refactors on its own, then rebui
     Then the process rests at "implement.building"
     And "src/calc.ts" contains "op(a, b, 1)"
     And "src/calc.ts" does not contain "subtract"
-    And the output of gtd "slices" contains "refactor "
 
   Scenario: the rebuild lands only once it carries the naive pass's acceptance tests, green
     Given step "seam.note" writes ".gtd/REFACTOR-NOTE.md" with:
@@ -285,8 +284,3 @@ Feature: refactor-first writes a refactor note, refactors on its own, then rebui
       gtd(check): implement.health.check → implement.closing
       gtd(check): implement.closing → build.review.reviewing
       """
-    And the output lines of gtd "slices" start with:
-      """
-      refactor
-      feature
-      """

package/src/workflows/feature/refactor-review.feature

@@ -1,9 +1,9 @@
 @inmem
-Feature: the refactor slice is reviewed on its own before the feature is implemented
+Feature: the refactor is reviewed on its own before the feature is implemented
 
   After a refactor-first judgment the refactor is built, quality-lapped and
-  reviewed in its own slice. Review edits re-run the refactor, never the design;
-  the feature slice that follows is quality-lapped from the refactor's
+  reviewed on its own. Review edits re-run the refactor, never the design;
+  the feature that follows is quality-lapped from the refactor's
   sign-off, then reviewed. The flags are pinned so the per-flag test runs never move it off
   its path.
 
@@ -614,7 +614,7 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
       And ".gtd/REFACTOR.md" does not exist
       And ".gtd/REVIEW.md" contains "A: add and subtract differ only by sign."
 
-    Scenario: a no-change landing after the in-gate reply signs off and the feature slice follows
+    Scenario: a no-change landing after the in-gate reply signs off and the feature follows
       Given step "implement.building" writes "src/calc.ts" with:
         """
         export const op = (a: number, b: number, sign: number) => a + sign * b
@@ -697,7 +697,7 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
       Then the process rests at "build.review.reviewing"
       And "src/calc.ts" contains "subtract"
 
-    Scenario: a praise-only one-shot footnote signs off and the feature slice follows
+    Scenario: a praise-only one-shot footnote signs off and the feature follows
       Given step "implement.building" writes "src/calc.ts" with:
         """
         export const op = (a: number, b: number, sign: number) => a + sign * b
@@ -979,7 +979,7 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
       Then driving the process is refused with "refactor-feedback"
       And driving the process is refused with "hand-edited src/calc.ts"
 
-    Scenario: a praise note and a concluded thread on a settled round sign off and the feature slice follows
+    Scenario: a praise note and a concluded thread on a settled round sign off and the feature follows
       Given step "implement.building" writes "src/calc.ts" with:
         """
         export const op = (a: number, b: number, sign: number) => a + sign * b
@@ -1066,7 +1066,7 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
       Then the process rests at "build.review.reviewing"
       And "src/calc.ts" contains "subtract"
 
-    Scenario: a praise-only refactor review still signs off and the feature slice follows
+    Scenario: a praise-only refactor review still signs off and the feature follows
       Given step "implement.building" writes "src/calc.ts" with:
         """
         export const op = (a: number, b: number, sign: number) => a + sign * b
@@ -1099,7 +1099,7 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
       Then the process rests at "build.review.reviewing"
       And "src/calc.ts" contains "subtract"
 
-    Scenario: a nit fix in the refactor slice that changes a non-stray is refused, though a glob stray widens the write access
+    Scenario: a nit fix in the refactor that changes a non-stray is refused, though a glob stray widens the write access
       Given step "seam.naive" writes "src/*.ts" with:
         """
         export const literalGlobName = 2
@@ -1130,7 +1130,7 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
       When gtd lands
       Then driving the process is refused with "refactor-scope"
 
-    Scenario: the nit-fix turn in the refactor slice may write the strays and .gtd/** only
+    Scenario: the nit-fix turn in the refactor may write the strays and .gtd/** only
       Given step "seam.naive" writes "src/*.ts" with:
         """
         export const literalGlobName = 2
@@ -1185,7 +1185,45 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
         """
       And no commit body contains "refactor.build.review.composing"
 
-  Rule: with a quality lens on both slices
+    Scenario: a risk the refactor's re-review marks again reaches the human unfixed
+      Given step "refactor.build.review.reviewing" writes ".gtd/REVIEW.md" with:
+        """
+        # Review: abc1234
+
+        <!-- base: 0000000 -->
+
+        ## calc
+
+        - [ ] ./src/calc.ts#1-2 — Risk: drops the sign
+        """
+      When the process is driven
+      Then the process rests at "refactor.build.review.fix.risks.fixing"
+      Given step "refactor.build.review.reviewing" is no longer scripted
+      And step "refactor.build.review.reviewing" replaces the text "Risk: drops the sign" in ".gtd/REVIEW.md" with "Risk: still drops the sign"
+      And step "refactor.build.review.fix.risks.fixing" changes nothing
+      And step "refactor.build.health.check" changes nothing
+      When the process is driven
+      Then the process rests at "refactor.build.review.await-review"
+      And ".gtd/REVIEW.md" contains:
+        """
+        ## Walkthrough
+
+        ### calc
+
+        - [ ] ./src/calc.ts#1-2 — Risk: still drops the sign
+        """
+      And ".gtd/REVIEW.md" contains "## Walkthrough" exactly once
+      And the commit subjects end with:
+        """
+        gtd(agent): refactor.build.review.reviewing → refactor.build.review.fix.risks.fixing
+        gtd(agent): refactor.build.review.fix.risks.fixing → refactor.build.health.check
+        gtd(check): refactor.build.health.check → refactor.build.review.reviewing
+        gtd(agent): refactor.build.review.reviewing → refactor.build.review.ranking
+        gtd(judge): refactor.build.review.ranking → refactor.build.review.carrying
+        gtd(check): refactor.build.review.carrying → refactor.build.review.await-review
+        """
+
+  Rule: with a quality lens on both the refactor and the feature
 
     Background:
       Given an environment variable "GTD_REFACTORQUALITYREVIEWS" set to "correctness"
@@ -1275,7 +1313,7 @@ Feature: the refactor slice is reviewed on its own before the feature is impleme
         """
       And step "refactor.build.review.closing" runs its script
 
-    Scenario: each slice's quality lap reviews from that slice's base
+    Scenario: the refactor's and the feature's quality laps each review from their own base
       When the process is driven
       Then the process rests at "refactor.build.quality.correctness.reviewing"
       And the resting step's content contains the hash of the commit "gtd(agent): seam.note → refactor.deriving"

package/src/workflows/feature/refactor.ts

@@ -15,9 +15,8 @@ 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, HANDOFF, REFACTOR } from "../shared/steps.js"
+import { coder, FEEDBACK, 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 "../shared/review.js"
@@ -264,12 +263,7 @@ 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,
-  refactor: Phase,
-  feedback?: string,
-): Promise<void> => {
+const refactorLap = async (p: Plan, guard: Guard, feedback?: string): Promise<void> => {
   const { pattern, strays, reference, note } = p
   await run(
     "deriving",
@@ -282,59 +276,32 @@ const refactorLap = async (
     ]),
     { label: "Deriving the refactor package", file: REFACTOR_PACKAGE },
   )
-  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",
-  })
+  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 strayAccess = (strays: readonly string[]) => ({
@@ -348,7 +315,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()), phase("refactor"))
+    await refactorLap(p, guardOf(p, head()))
     return true
   })
 }
@@ -375,10 +342,9 @@ 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, refactor, collected)
+      await refactorLap(p, guard, 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/review-gate.feature

@@ -1,7 +1,7 @@
 @inmem
 Feature: a feature process ends at the human review
 
-  After the last slice's quality lap the process rests at the review gate,
+  After the quality lap the process rests at the review gate,
   `.gtd/REVIEW.md`. A sign-off ends the process. A note asking for a change in
   behaviour starts a feedback lap — design, then implement with no new naive
   pass or seam judge, the hands-on test, the quality lap — and the review

package/src/workflows/feature/reviewer-walkthrough.feature

@@ -179,37 +179,6 @@ Feature: a reviewer walks the human through the feature's code
       """
     Then driving the process is refused with "AC-1 ignores floating point — no chunk of its own"
 
-  Scenario: a risk the reviewer marks is fixed before the human sees the review
-    Given step "build.review.reviewing" writes ".gtd/REVIEW.md" with:
-      """
-      # Review: abc1234
-
-      <!-- base: 0000000 -->
-
-      ## Subtract
-
-      - [ ] ./src/calc.ts#2-2 — Risk: overflows on large numbers
-
-      ## AC-1 ignores floating point
-
-      - [ ] ./src/calc.ts#2-2 — returns the raw difference
-      """
-    And step "build.review.fix.risks.fixing" changes nothing
-    And step "build.health.check" changes nothing
-    When the process is driven
-    Then the process rests at "build.review.await-review"
-    And the commit subjects end with:
-      """
-      gtd(agent): build.review.reviewing → build.review.ranking
-      gtd(judge): build.review.ranking → build.review.carrying
-      gtd(check): build.review.carrying → build.review.fix.risks.fixing
-      gtd(agent): build.review.fix.risks.fixing → build.health.check
-      gtd(check): build.health.check → build.review.reviewing
-      gtd(agent): build.review.reviewing → build.review.ranking
-      gtd(judge): build.review.ranking → build.review.carrying
-      gtd(check): build.review.carrying → build.review.await-review
-      """
-
   Scenario: a standard conflict the reviewer writes itself is refused
     Given step "build.review.reviewing" writes ".gtd/REVIEW.md" with:
       """

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

@@ -136,8 +136,4 @@ Feature: rejected naive passes walk one fixed path through the steer gate to the
     And the commit "gtd(judge): seam.judge → seam.steer" has a body containing "\"answer\":\"reject\""
     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/seam.test.ts

@@ -311,9 +311,6 @@ const reviewDoc = [
 
 interface Seamed {
   readonly names: string[]
-  readonly slices: string[]
-  /** Slice names entered, with the steps seen while inside each. */
-  readonly inside: Record<string, string[]>
   readonly outcome: SeamOutcome | Error
 }
 
@@ -327,10 +324,7 @@ const driveSeam = async (
   let red = false
   let redsLeft = reds
   const names: string[] = []
-  const slices: string[] = []
-  const inside: Record<string, string[]> = {}
   const stack: string[] = []
-  const open: string[] = []
   const files = new Map<string, string>([["src/a.ts", "a"]])
   let current = "c0"
   const effects: Record<string, () => void> = {
@@ -351,12 +345,6 @@ const driveSeam = async (
     },
     pushScope: (scope: { name?: string }) => void stack.push(scope.name ?? ""),
     popScope: () => void stack.pop(),
-    enterSlice: (name: string) => {
-      slices.push(name)
-      open.push(name)
-      inside[name] = []
-    },
-    leaveSlice: () => void open.pop(),
     read: (path: string) => files.get(path),
     head: () => current,
     kept: () => tip(stray),
@@ -372,7 +360,6 @@ const driveSeam = async (
       }
       if (full === "seam.clear") files.delete(".gtd/FEEDBACK.md")
       names.push(full)
-      for (const name of open) inside[name]!.push(full)
       effects[request.name]?.()
       if (request.kind === "judge")
         return Promise.resolve({ answers: { shape: { answer, p: 0.9 } }, truncated: [] })
@@ -385,14 +372,13 @@ const driveSeam = async (
   } catch (error) {
     outcome = error as Error
   }
-  return { names, slices, inside, outcome }
+  return { names, outcome }
 }
 
 describe("seamBuild", () => {
-  it("land resolves the kept tip to land, with the caller's base, and enters no slice", async () => {
+  it("land resolves the kept tip to land, with the caller's base", async () => {
     const h = await driveSeam("land")
     expect(h.outcome).toEqual({ reference: "abc", base: "c-base", land: true })
-    expect(h.slices).toEqual([])
     expect(h.names).toEqual(["seam.naive", "seam.check", "seam.judge"])
   })
 
@@ -432,7 +418,7 @@ describe("seamBuild", () => {
     expect(h.outcome).toEqual({ reference: "abc", base: "c-base", land: true })
   })
 
-  it("refactor-first runs the reviewed refactor in slice refactor and resolves HEAD after it", async () => {
+  it("refactor-first runs the reviewed refactor right after the note and resolves HEAD after it", async () => {
     const h = await driveSeam("refactor-first")
     expect(h.outcome).toEqual({
       reference: "abc",
@@ -440,16 +426,14 @@ describe("seamBuild", () => {
       refactored: true,
       rebuild: { note: "Seam: a shared op", acceptance: { hash: "abc", tests: [], ids: [] } },
     })
-    expect(h.slices).toEqual(["refactor"])
     expect(h.names.indexOf("seam.note")).toBe(h.names.indexOf("seam.judge") + 1)
-    expect(h.inside.refactor).not.toContain("seam.note")
-    expect(h.inside.refactor![0]).toBe("refactor.deriving")
-    expect(h.inside.refactor).toContain("refactor.build.review.closing")
+    expect(h.names.indexOf("refactor.deriving")).toBe(h.names.indexOf("seam.note") + 1)
+    expect(h.names).toContain("refactor.build.review.closing")
     expect(h.names.some((n) => n.includes("approve"))).toBe(false)
     expect(h.names.some((n) => n.startsWith("implement"))).toBe(false)
   })
 
-  it("refactor-first with only test-file strays resolves the caller's base with no slice and no by-hand", async () => {
+  it("refactor-first with only test-file strays resolves the caller's base with no refactor and no by-hand", async () => {
     const h = await driveSeam("refactor-first", change("src/a.test.ts", "modified"), {
       seamAllow: ".gtd/**",
     })
@@ -458,7 +442,6 @@ describe("seamBuild", () => {
       base: "c-base",
       rebuild: { acceptance: { hash: "abc", tests: [], ids: [] } },
     })
-    expect(h.slices).toEqual([])
     expect(h.names).not.toContain("seam.by-hand")
     expect(h.names.some((n) => n.startsWith("refactor"))).toBe(false)
   })
@@ -469,18 +452,16 @@ describe("seamBuild", () => {
       { path: "src/a.test.ts", status: "modified", before: undefined, after: "b" },
       { seamAllow: ".gtd/**" },
     )
-    expect(h.slices).toEqual([])
     expect(h.names).toContain("seam.by-hand")
   })
 
-  it("rests unreadable strays at seam.by-hand and enters no refactor slice", async () => {
+  it("rests unreadable strays at seam.by-hand and runs no refactor", async () => {
     const h = await driveSeam("refactor-first", {
       path: "src/a.ts",
       status: "modified",
       before: undefined,
       after: "b",
     })
-    expect(h.slices).toEqual([])
     expect(h.names).toContain("seam.by-hand")
     expect(h.outcome).toEqual({
       reference: "abc",