@pmelab/gtd 52.0.0 → 53.0.0

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

@@ -109,7 +109,8 @@ describe("naivePass", () => {
 })
 
 describe("naiveAcceptance and requireAcceptance", () => {
-  const requirements = "# R\n\n## Acceptance Criteria\n\n- AC-1: adds.\n- AC-2: subtracts.\n"
+  const requirements =
+    "# R\n\n## Impact\n\n- the module\n\n## Acceptance Criteria\n\n- AC-1: adds.\n- AC-2: subtracts.\n"
   const file = (path: string, before: string | undefined, after: string): Change => ({
     path,
     status: before === undefined ? "added" : "modified",
@@ -170,7 +171,8 @@ describe("naiveAcceptance and requireAcceptance", () => {
 })
 
 describe("acceptanceFault", () => {
-  const requirements = "# R\n\n## Acceptance Criteria\n\n- AC-1: adds.\n- AC-2: subtracts.\n"
+  const requirements =
+    "# R\n\n## Impact\n\n- the module\n\n## Acceptance Criteria\n\n- AC-1: adds.\n- AC-2: subtracts.\n"
   const file = (path: string, status: Change["status"], after: string): Change => ({
     path,
     status,
@@ -309,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
 }
 
@@ -325,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> = {
@@ -349,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),
@@ -370,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: [] })
@@ -383,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"])
   })
 
@@ -430,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",
@@ -438,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/**",
     })
@@ -456,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)
   })
@@ -467,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",

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/feature/severity-budget.feature

@@ -28,6 +28,10 @@ Feature: the review's ranking is batched to the judge's budget
       """
       # Requirements
 
+      ## Impact
+
+      - the greeting module
+
       ## Acceptance Criteria
 
       - AC-1: subtract(a, b) returns a - b.

package/src/workflows/feature/severity-sorted-review.feature

@@ -31,6 +31,10 @@ Feature: the final review lists the findings that matter most first
       """
       # Requirements
 
+      ## Impact
+
+      - the greeting module
+
       ## Acceptance Criteria
 
       - AC-1: subtract(a, b) returns a - b.

package/src/workflows/feature/standards.feature

@@ -37,6 +37,10 @@ Feature: the review learns standards from the human's answers
 
       - `subtract(a, b)` returns `a - b`.
 
+      ## Impact
+
+      - the greeting module
+
       ## Acceptance Criteria
 
       - AC-1: subtract(a, b) returns a - b.

package/src/workflows/feature/tier-pin.feature

@@ -34,6 +34,10 @@ Feature: a process keeps the risk tier setting it started with when GTD_FLAG_RIS
 
       low — a new pure function
 
+      ## Impact
+
+      - the greeting module
+
       ## Acceptance Criteria
 
       - AC-1: the change behaves as described.

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 ?? "" }) } },