@pmelab/gtd 36.0.0 → 38.0.0

package/src/wire/ContextLimit.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, it } from "vitest"
+import {
+  CONTEXT_LIMIT_MARKER,
+  DEFAULT_CONTEXT_LIMIT,
+  contextHook,
+  contextLimitFault,
+  contextWindowFor,
+  hookOutput,
+  subagentTranscriptPath,
+  transcriptTokens,
+} from "./ContextLimit.js"
+import { transcriptAt } from "./ContextLimit.fixture.js"
+
+const at = (tokens: number, event: "PostToolUse" | "PreCompact" = "PostToolUse") =>
+  contextHook({
+    event,
+    tokens: transcriptTokens(transcriptAt(tokens)),
+    window: 200_000,
+    limit: DEFAULT_CONTEXT_LIMIT,
+  })
+
+describe("transcriptTokens", () => {
+  it("counts the latest assistant message's input, cache-read and cache-creation tokens", () => {
+    expect(transcriptTokens(transcriptAt(50_000))).toBe(50_000)
+  })
+
+  it("is undefined for a transcript with no assistant usage yet", () => {
+    expect(transcriptTokens('{"type":"user"}\nnot json\n')).toBeUndefined()
+  })
+})
+
+describe("contextHook", () => {
+  it("lets a run below the soft limit go on", () => {
+    expect(at(119_999)).toBeUndefined()
+  })
+
+  it("blocks with a handoff-note request at the soft limit", () => {
+    const decision = at(120_000)
+    expect(decision?.kind).toBe("soft")
+    expect(hookOutput(decision!)).toEqual({
+      decision: "block",
+      reason: expect.stringContaining("short handoff note"),
+    })
+  })
+
+  it("stops the run at the hard limit, behind the marker", () => {
+    const decision = at(140_000)
+    expect(hookOutput(decision!)).toEqual({
+      continue: false,
+      stopReason: expect.stringMatching(new RegExp(`^${CONTEXT_LIMIT_MARKER}: 140000 of 200000`)),
+    })
+  })
+
+  it("stops the run on PreCompact, whatever the count", () => {
+    expect(hookOutput(at(1_000, "PreCompact")!)).toEqual({
+      continue: false,
+      stopReason: expect.stringContaining(
+        `${CONTEXT_LIMIT_MARKER}: the context is about to be compacted`,
+      ),
+    })
+  })
+
+  it("lets a run with no usage yet go on", () => {
+    const limit = DEFAULT_CONTEXT_LIMIT
+    expect(
+      contextHook({ event: "PostToolUse", tokens: undefined, window: 1, limit }),
+    ).toBeUndefined()
+  })
+})
+
+describe("contextLimitFault", () => {
+  it("accepts shares in (0, 1] with soft below hard", () => {
+    expect(contextLimitFault({ soft: 0.5, hard: 1 })).toBeUndefined()
+    expect(contextLimitFault({ hard: 0.9 })).toBeUndefined()
+  })
+
+  it("refuses a share outside (0, 1] and a soft limit at or above the hard one", () => {
+    expect(contextLimitFault({ soft: 0 })).toMatch(/context\.soft must be/)
+    expect(contextLimitFault({ hard: 70 })).toMatch(/context\.hard must be/)
+    expect(contextLimitFault({ soft: 0.8 })).toMatch(/below context\.hard \(0\.7\)/)
+    const misspelt: { hard: number } = Object.assign({ hard: 0.8 }, { sotf: 0.5 })
+    expect(contextLimitFault(misspelt)).toBe("unknown key(s) sotf in context")
+  })
+})
+
+it("reads the long window from Claude Code's [1m] suffix only", () => {
+  expect(contextWindowFor("opus[1m]")).toBe(1_000_000)
+  expect(contextWindowFor("opus")).toBe(200_000)
+  expect(contextWindowFor(undefined)).toBe(200_000)
+})
+
+it("finds a worker's own transcript beside the main session's", () => {
+  expect(subagentTranscriptPath("/p/session.jsonl", "a1")).toBe(
+    "/p/session/subagents/agent-a1.jsonl",
+  )
+})

package/src/wire/ContextLimit.ts

@@ -0,0 +1,169 @@
+// The context-limit decision every driver shares: the loop's `gtd context-hook`
+// and the Claude Code mod both answer a hook event through `contextHook`, so
+// the two cannot drift on thresholds, wording or which tokens count.
+
+/** A share of the model's context window, each in (0, 1]; `soft` below `hard`. */
+export interface ContextLimit {
+  readonly soft: number
+  readonly hard: number
+}
+
+export const DEFAULT_CONTEXT_LIMIT: ContextLimit = { soft: 0.6, hard: 0.7 }
+
+const DEFAULT_WINDOW = 200_000
+const LONG_WINDOW = 1_000_000
+
+/** Claude Code's `[1m]` suffix selects the long window; a transcript never names it, so the driver decides from the model it passed. */
+export const contextWindowFor = (model: string | undefined): number =>
+  model !== undefined && /\[1m\]/i.test(model) ? LONG_WINDOW : DEFAULT_WINDOW
+
+/** A positive whole number of tokens, or `undefined` for anything else. */
+export const parseContextWindow = (raw: string | undefined): number | undefined => {
+  const n = Number(raw)
+  return raw !== undefined && raw.trim() !== "" && Number.isInteger(n) && n > 0 ? n : undefined
+}
+
+/** `gtd context-hook`'s request: the hook's stdin and the limits its flags set. */
+export interface ContextHookRequest {
+  readonly input: string
+  readonly soft?: number
+  readonly hard?: number
+  readonly window?: number
+}
+
+/**
+ * Where a driver asks `gtd context-hook` to record a hard stop's `stopReason`:
+ * Claude Code prints it nowhere a driver reads, and `hook_stopped` alone would
+ * also name any other hook that stopped the turn.
+ */
+export const CONTEXT_STOP_FILE_ENV = "GTD_LOOP_CONTEXT_STOP_FILE"
+
+/**
+ * Why one layer of a limit (a scope's, a step's) is malformed, ignoring how its
+ * two shares relate: layers merge key by key, so only the merged limit has to
+ * keep `soft` below `hard`. Config is evaluated untyped, so anything may arrive.
+ */
+export const contextShapeFault = (limit: unknown): string | undefined => {
+  if (typeof limit !== "object" || limit === null || Array.isArray(limit)) {
+    return `context must be an object { soft, hard }, got ${JSON.stringify(limit)}`
+  }
+  const unknown = Object.keys(limit).filter((key) => key !== "soft" && key !== "hard")
+  if (unknown.length > 0) return `unknown key(s) ${unknown.join(", ")} in context`
+  const shares = limit as { readonly soft?: unknown; readonly hard?: unknown }
+  for (const key of ["soft", "hard"] as const) {
+    const value = shares[key]
+    if (value === undefined) continue
+    if (typeof value !== "number" || !(value > 0 && value <= 1)) {
+      return `context.${key} must be a share of the context window in (0, 1], got ${JSON.stringify(value)}`
+    }
+  }
+  return undefined
+}
+
+/** Why a whole limit is unusable, or `undefined` when it is fine. */
+export const contextLimitFault = (limit: unknown): string | undefined => {
+  const shape = contextShapeFault(limit)
+  if (shape !== undefined) return shape
+  const shares = limit as { readonly soft?: unknown; readonly hard?: unknown }
+  const soft = (shares.soft as number | undefined) ?? DEFAULT_CONTEXT_LIMIT.soft
+  const hard = (shares.hard as number | undefined) ?? DEFAULT_CONTEXT_LIMIT.hard
+  return soft < hard ? undefined : `context.soft (${soft}) must be below context.hard (${hard})`
+}
+
+const record = (value: unknown): Record<string, unknown> | undefined =>
+  typeof value === "object" && value !== null ? (value as Record<string, unknown>) : undefined
+
+const count = (value: unknown): number => (typeof value === "number" && value > 0 ? value : 0)
+
+/** What a message's usage puts in the context window: its whole input, cached or not. */
+export const usageTokens = (usage: unknown): number | undefined => {
+  const u = record(usage)
+  if (u === undefined) return undefined
+  return (
+    count(u["input_tokens"]) +
+    count(u["cache_read_input_tokens"]) +
+    count(u["cache_creation_input_tokens"])
+  )
+}
+
+/**
+ * The context size of the latest assistant message in a Claude Code transcript
+ * (one JSON entry per line). Usage is per message, not a running sum, so the
+ * last entry alone is the window's fill.
+ */
+export const transcriptTokens = (transcript: string): number | undefined => {
+  const lines = transcript.split("\n")
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i]!.trim()
+    if (line === "") continue
+    let entry: unknown
+    try {
+      entry = JSON.parse(line)
+    } catch {
+      continue
+    }
+    if (record(entry)?.["type"] !== "assistant") continue
+    const tokens = usageTokens(record(record(entry)?.["message"])?.["usage"])
+    if (tokens !== undefined) return tokens
+  }
+  return undefined
+}
+
+/**
+ * A worker subagent's own transcript. A hook its tool call fires is handed the
+ * MAIN session's `transcript_path`; the worker's sits beside it.
+ */
+export const subagentTranscriptPath = (transcriptPath: string, agentId: string): string =>
+  `${transcriptPath.replace(/\.jsonl$/, "")}/subagents/agent-${agentId}.jsonl`
+
+/** Every hard stop's `stopReason` starts with this: the driver's context-limit marker. */
+export const CONTEXT_LIMIT_MARKER = "gtd: context limit"
+
+export type ContextEvent = "PostToolUse" | "PreCompact"
+
+export type ContextDecision =
+  | { readonly kind: "soft"; readonly reason: string }
+  | { readonly kind: "hard"; readonly stopReason: string }
+
+const percent = (share: number): string => `${Math.round(share * 100)}%`
+
+/**
+ * What a hook answers, or `undefined` to let the run go on. Compaction about
+ * to happen means the limit was missed, so `PreCompact` is a hard stop whatever
+ * the count says.
+ */
+export const contextHook = (input: {
+  readonly event: ContextEvent
+  readonly tokens: number | undefined
+  readonly window: number
+  readonly limit: ContextLimit
+}): ContextDecision | undefined => {
+  const { event, tokens, window, limit } = input
+  if (event === "PreCompact") {
+    return {
+      kind: "hard",
+      stopReason: `${CONTEXT_LIMIT_MARKER}: the context is about to be compacted — the run is too big for one turn`,
+    }
+  }
+  if (tokens === undefined) return undefined
+  const used = `${tokens} of ${window} tokens`
+  if (tokens >= limit.hard * window) {
+    return {
+      kind: "hard",
+      stopReason: `${CONTEXT_LIMIT_MARKER}: ${used}, past the ${percent(limit.hard)} hard limit`,
+    }
+  }
+  if (tokens >= limit.soft * window) {
+    return {
+      kind: "soft",
+      reason: `Context limit: ${used} used, past the ${percent(limit.soft)} soft limit. Stop working now. Do not start anything new; end your turn with a short handoff note as your answer: what you touched, and what was next.`,
+    }
+  }
+  return undefined
+}
+
+/** A decision as Claude Code's settings-hook JSON output. */
+export const hookOutput = (decision: ContextDecision): Record<string, unknown> =>
+  decision.kind === "soft"
+    ? { decision: "block", reason: decision.reason }
+    : { continue: false, stopReason: decision.stopReason }

package/src/wire/index.ts

@@ -11,3 +11,4 @@ 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,6 +38,12 @@ 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
@@ -51,4 +57,5 @@ export interface RenderedDemandSource {
   readonly judge?: string
   readonly skills?: readonly string[]
   readonly access?: StepAccess
+  readonly context?: StepContextLimit
 }

package/src/workflow/Workflow.ts

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

package/src/workflows/feature/context-limit.feature

@@ -0,0 +1,37 @@
+@inmem
+Feature: the shipped workflows take a context limit as an option
+
+  `contextLimit: { soft, hard }` is a factory option: every agent step of the
+  workflow runs under it, carried as `gtd next --json`'s `context`. Without it a
+  step carries none and the driver's defaults apply.
+
+  Scenario Outline: every agent step carries the configured limit, or none
+    Given a gtd config with:
+      """
+      import { feature } from "@pmelab/gtd/workflows/feature"
+      export { summary, steering, skills, access } from "@pmelab/gtd/workflows/feature"
+      export default feature(<options>)
+      """
+    And a file "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => a + b
+      """
+    And the working tree is committed as "feat: add calculator"
+    And a file "TODO.md" with:
+      """
+      # Add subtract
+
+      subtract(a, b) returns the difference.
+      """
+    And step "unwind" changes nothing
+    And step "start-gate.check" changes nothing
+    When the process is driven
+    Then the process rests at "design.triage"
+    And the output of gtd "next --json" <carries>
+
+    Examples:
+      | options                                     | carries                                             |
+      | { contextLimit: { soft: 0.5, hard: 0.65 } } | contains "\"context\":{\"soft\":0.5,\"hard\":0.65}" |
+      | { contextLimit: { hard: 0.8 } }             | contains "\"context\":{\"hard\":0.8}"               |
+      | {}                                          | does not contain "\"context\""                      |
+

package/src/workflows/feature/coverage.ts

@@ -11,7 +11,13 @@ import {
 import { healthy } from "../shared/health.js"
 import { coder, FEEDBACK, REQUIREMENTS } from "../shared/steps.js"
 import * as t from "../shared/text.js"
-import { criteriaOf, requireCriteriaFrozen } from "./criteria.js"
+import {
+  criteriaOf,
+  criterionIds,
+  requireCriteriaFrozen,
+  sliceIds,
+  type CriteriaSlice,
+} from "./criteria.js"
 import { isTestFile } from "./refactor.js"
 import { isCode } from "./review.js"
 
@@ -23,7 +29,7 @@ const COVERING_RETRIES = 2
 
 const frozen = (): void => requireCriteriaFrozen(REQUIREMENTS)
 
-export const green = (): Promise<void> =>
+export const green = (guard?: () => void): Promise<void> =>
   healthy(
     () =>
       t.agentWithSkills("fix.suite.fixing", t.implementFixPrompt(), {
@@ -32,7 +38,13 @@ export const green = (): Promise<void> =>
         model: coder(),
         system: t.builderSystem(),
       }),
-    { guard: frozen, guardRests: false },
+    {
+      guard: () => {
+        frozen()
+        guard?.()
+      },
+      guardRests: false,
+    },
   )
 
 // A budget cut keeps the end, so the files naming a criterion ID go last.
@@ -45,13 +57,15 @@ const testsSince = (base: string): string =>
 
 /**
  * The criterion IDs of `.gtd/REQUIREMENTS.md` — read afresh, never carried
- * over — no passing test since `base` covers, by the judge.
+ * over, only `slice`'s when given — no passing test since `base` covers, by the judge.
  */
 const uncoveredSince = async (
   base: string,
+  slice: CriteriaSlice | undefined,
 ): Promise<{ readonly covered: string[]; readonly uncovered: string[] }> => {
   const requirements = read(REQUIREMENTS) ?? ""
-  const criteria = (criteriaOf(requirements) ?? []).filter((c) => c.id !== "")
+  const own = criterionIds(requirements, slice)
+  const criteria = (criteriaOf(requirements) ?? []).filter((c) => own.includes(c.id))
   if (criteria.length === 0) return { covered: [], uncovered: [] }
   const { answers } = await judge("coverage", {
     questions: criteria.map(t.coverageQuestion),
@@ -75,14 +89,14 @@ const record = (covered: readonly string[], uncovered: readonly string[] = []):
  * sending uncovered IDs back to a covering turn; marks the IDs covered on the
  * landing that ends it. A human may overrule once the retries are spent.
  */
-export const requireCoverage = async (base = start()): Promise<void> => {
+export const requireCoverage = async (base = start(), slice?: CriteriaSlice): Promise<void> => {
   let retries = 0
   for (;;) {
-    const { covered, uncovered } = await uncoveredSince(base)
+    const { covered, uncovered } = await uncoveredSince(base, slice)
     if (uncovered.length === 0) return record(covered)
     if (retries < COVERING_RETRIES) {
       retries++
-      await t.agentWithSkills("covering", t.coveringPrompt(uncovered), {
+      await t.agentWithSkills("covering", t.coveringPrompt(uncovered, sliceIds(slice)), {
         label: "Covering the acceptance criteria",
         model: coder(),
         system: t.builderSystem(),

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

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest"
 import type { Change } from "../../flows/index.js"
-import { criteriaOf, statedCriteria } from "./criteria.js"
+import { criteriaOf, criterionIds, statedCriteria } from "./criteria.js"
 
 const added = (path: string, after: string): Change => ({
   path,
@@ -104,3 +104,19 @@ describe("statedCriteria", () => {
     ).toBeUndefined()
   })
 })
+
+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", () => {
+    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"])
+  })
+})

package/src/workflows/feature/criteria.ts

@@ -8,7 +8,7 @@ import {
   scope,
   type Change,
 } from "../../flows/index.js"
-import { markFenced } from "../shared/fences.js"
+import { HEADING, ITEM, markFenced } from "../shared/fences.js"
 import { REQUIREMENTS } from "../shared/steps.js"
 import * as t from "../shared/text.js"
 
@@ -29,8 +29,6 @@ export interface StatedCriteria {
 /** Below this the judge's `yes` is not trusted: a wrong skip builds against criteria nobody can check. */
 const CLEAR_MIN_P = 0.8
 
-const HEADING = /^ {0,3}(#{1,6})\s+(.*?)\s*#*\s*$/
-const ITEM = /^ ?(?:[-*+]|\d+[.)])\s+(?:\[[ xX]\]\s+)?(.*)$/
 const ID = /^(AC-\d+):\s*(.*)$/
 
 /** The list items under the first heading `title` matches (at `level` when given), up to the next heading; wrapped lines joined, fenced lines ignored. */
@@ -71,6 +69,31 @@ export const criteriaOf = (text: string): readonly Criterion[] | undefined =>
     return id === null ? { id: "", text: item } : { id: id[1]!, text: id[2]! }
   })
 
+/**
+ * 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),
+    )
+
+/** `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))

package/src/workflows/feature/feature.ts

@@ -11,21 +11,29 @@ import {
 } from "../../flows/index.js"
 import { gate, healthy } from "../shared/health.js"
 import { flagModeOn, shipped } from "../shared/options.js"
-import { FEEDBACK, fixCheck, QUALITY } from "../shared/steps.js"
+import { FEEDBACK, fixCheck, QUALITY, REQUIREMENTS } from "../shared/steps.js"
 import { refusePendingHandOff, tail } from "../shared/tail.js"
 import * as t from "../shared/text.js"
-import { skipDesign, statedCriteria, type StatedCriteria } from "./criteria.js"
+import {
+  requireCriteriaFrozen,
+  skipDesign,
+  sliceIds,
+  statedCriteria,
+  type CriteriaSlice,
+  type StatedCriteria,
+} from "./criteria.js"
 import { design } from "./planning.js"
 import { buildTail, isCode, reUnwind, type ReviewOutcome } from "./review.js"
-import { implement, seamBuild } from "./seam.js"
-import { recordRisk, riskTierOn } from "./tier.js"
+import { closeOut, implement, seamBuild } from "./seam.js"
+import { sliceCap, sliceCriteria, slicing } from "./slicing.js"
+import { recordRisk, riskTierOn, type RiskTier } from "./tier.js"
 
 // The ordinary start. Any change to the tree starts a process: `idle` →
 // `unwind` reverts the sketch (its intent survives in history) → a
-// green-baseline gate → design → a naive pass, judged with `flagMode` on: it
-// lands as the implementation, or (refactoring first when the judge asks) is
-// built fresh from → the health loop → the quality lap, and the episode ends
-// back at `idle`. Human review is the `review` door's.
+// green-baseline gate → design → per slice of the criteria, a naive pass,
+// judged with `flagMode` on: it lands as the implementation, or (refactoring
+// first when the judge asks) is built fresh from → the health loop → the
+// quality lap, and the episode ends back at `idle`. Human review is the `review` door's.
 
 /** Revert the sketch that started the process out of the working tree; its intent survives in history. */
 export const unwind = (): Promise<void> => {
@@ -37,23 +45,67 @@ export const unwind = (): Promise<void> => {
 
 export { reUnwind }
 
-/** A naive pass (judged only with `flagMode` on), then implement and the quality lap; design must have run since `firstBase`. */
+/**
+ * The slices `design.slicing` grouped the criteria into, each built in turn
+ * from where the previous one landed; design must have run since `firstBase`.
+ */
 export const buildFeature = async (firstBase: string): Promise<void> => {
   const tier = riskTierOn() ? recordRisk() : undefined
-  const seam = await seamBuild(firstBase)
-  await slice("feature", async () => {
+  const slices = await slicing()
+  // A single slice keeps the unnumbered names and builds against every criterion.
+  const one = slices.length === 1
+  for (const i of slices.keys()) {
+    const more = i < slices.length - 1
+    const criteria = sliceCriteria(slices, i)
+    // A steer may have deleted every criterion of a later slice: nothing to build.
+    if (sliceIds(criteria)?.length === 0) {
+      if (!more) await closeOut()
+      continue
+    }
+    const n = one ? "" : `-${i + 1}`
+    await buildSlice(i === 0 ? firstBase : head(), {
+      tier,
+      criteria,
+      refactor: `refactor${n}`,
+      feature: `feature${n}`,
+      more,
+    })
+  }
+}
+
+interface SliceBuild {
+  readonly tier: RiskTier | undefined
+  readonly criteria: CriteriaSlice | undefined
+  readonly refactor: string
+  readonly feature: string
+  readonly more: boolean
+}
+
+/** A naive pass (judged only with `flagMode` on), then implement and the quality lap. */
+const buildSlice = async (sliceBase: string, build: SliceBuild): Promise<void> => {
+  const seam = await seamBuild(sliceBase, { criteria: build.criteria, refactor: build.refactor })
+  await slice(build.feature, async () => {
     await implement({
       reference: seam.reference,
-      tier,
+      tier: build.tier,
       afterRefactor: seam.refactored,
       naive: seam.land === true ? seam.reference : undefined,
+      rebuild: seam.rebuild,
+      slice: build.criteria,
+      base: build.criteria === undefined ? undefined : sliceBase,
+      more: build.more,
     })
-    // An empty feature slice: the refactor carried the feature, so the lap covers the whole change.
+    // 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))
-        ? firstBase
+      seam.refactored === true &&
+      !changesSince(seam.base).some((c) => isCode(c.path) && !carried.includes(c.path))
+        ? sliceBase
         : seam.base
-    await tail(settleQuality, { green: true, lensBase: base })
+    // The criteria stay in the tree for the next slice; no quality fix may move them.
+    const guard = build.more ? () => requireCriteriaFrozen(REQUIREMENTS) : undefined
+    await tail(settleQuality, { green: true, lensBase: base, guard, guardRests: false })
   })
 }
 
@@ -99,6 +151,7 @@ export const ordinaryStart = async (): Promise<void> => {
   refusePendingHandOff()
   // Read right after idle, so a bad value refuses the landing that would pin it.
   flagModeOn()
+  sliceCap()
   const stated = statedCriteria(changes(), head())
   await unwind()
   if (changes(FEEDBACK).some((c) => c.status !== "deleted")) {

package/src/workflows/feature/index.ts

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