@pmelab/gtd 52.1.0 → 53.0.0

package/src/edge/Edge.test.ts

@@ -6,7 +6,6 @@ import {
   currentRun,
   historyTrail,
   noProcessUnderway,
-  processSlices,
   renderRest,
   restAt,
   restIsIdle,
@@ -609,172 +608,15 @@ const withTipMessage = (repo: InMemRepo, edit: (message: string) => string): Git
   }
 }
 
-describe("processSlices", () => {
-  const failure = async (repo: InMemRepo): Promise<string> => {
-    const exit = await provideExit(processSlices, repo)
-    expect(Exit.isFailure(exit)).toBe(true)
-    return Exit.isFailure(exit) ? String(exit.cause) : ""
-  }
-
-  it("never reports an open slice for a closed run whose replay no longer ends", async () => {
-    const repo = repoWith(LINEAR)
-    await land(repo, { "a.txt": "a\n" })
-    await land(repo, { "b.txt": "b\n" })
-    await land(repo, { "c.txt": "c\n" })
-    repo.writeFile(
-      "gtd.config.ts",
-      LINEAR.replace(
-        'await agent("checking", "check-prompt")',
-        'await agent("checking", "check-prompt")\n  await human("idle", { message: "again" })\n  await agent("polishing", "polish-prompt")',
-      ),
-    )
-    // Stands for a flow change with no in-repo config edit (an upgraded
-    // out-of-repo import): every ref reads as the working tree, so the
-    // config-differs refusal stays quiet and only replay drift remains.
-    const git: GitOperations = {
-      ...fakeGitOperations(repo),
-      readFileAtRef: (_ref, path) => Effect.succeed(repo.readFile(path) ?? ""),
-    }
-    const exit = await Effect.runPromiseExit(
-      processSlices.pipe(
-        Effect.provideService(GitService, git),
-        Effect.provide(testLayers(repo, {})),
-      ),
-    )
-    expect(Exit.isFailure(exit)).toBe(true)
-    const message = Exit.isFailure(exit) ? String(exit.cause) : ""
-    expect(message).toContain(
-      `gtd slices: refused — ${repo.resolveRef("HEAD")!.slice(0, 7)} closes a process that does not end under today's config`,
-    )
-  })
-
-  it("never reports a closed slice for an underway run whose replay now ends", async () => {
-    const repo = repoWith(LINEAR)
-    await land(repo, { "a.txt": "a\n" })
-    await land(repo, { "b.txt": "b\n" })
-    repo.writeFile(
-      "gtd.config.ts",
-      LINEAR.replace('  await agent("checking", "check-prompt")\n', ""),
-    )
-    const message = await failure(repo)
-    expect(message).toContain("gtd slices: refused")
-    expect(message).toContain("the workflow changed under this process")
-    expect(message).toContain("gtd abandon")
-    expect(message).not.toContain("gtd slices: gtd:")
-  })
-
-  it("refuses with no process at HEAD, naming that HEAD neither closes nor sits inside one", async () => {
-    const repo = repoWith(LINEAR)
-    expect(await failure(repo)).toContain(
-      "gtd slices: refused — HEAD neither closes nor sits inside a process",
-    )
-  })
-
-  it("refuses a renamed step with replay's message, prefixed and without a gtd: lead", async () => {
-    const repo = repoWith(LINEAR)
-    await land(repo, { "a.txt": "a\n" })
-    repo.writeFile("gtd.config.ts", LINEAR.replace('agent("building"', 'agent("constructing"'))
-    const message = await failure(repo)
-    expect(message).toContain("gtd slices: refused — ")
-    expect(message).not.toContain("HEAD neither closes nor sits inside a process")
-    expect(message).not.toContain("refused — gtd: ")
-    expect(message).not.toContain("gtd slices: gtd:")
-  })
-
-  it("refuses a finished process whose config file was edited since", async () => {
-    const repo = repoWith(LINEAR)
-    await land(repo, { "a.txt": "a\n" })
-    await land(repo, { "b.txt": "b\n" })
-    await land(repo, { "c.txt": "c\n" })
-    repo.writeFile("gtd.config.ts", `${LINEAR}\n// edited\n`)
-    const message = await failure(repo)
-    expect(message).toContain(
-      `gtd slices: refused — config differs at ${repo.resolveRef("HEAD")!.slice(0, 7)}: gtd.config.ts. HEAD's process replays under today's config; revert or stash the edit to list its slices`,
-    )
-  })
-
-  const finishedProcess = async () => {
-    const repo = repoWith(LINEAR)
-    await land(repo, { "a.txt": "a\n" })
-    await land(repo, { "b.txt": "b\n" })
-    await land(repo, { "c.txt": "c\n" })
-    return repo
-  }
-  const slicesWith = (repo: InMemRepo, git: GitOperations) =>
-    Effect.runPromise(
-      processSlices.pipe(
-        Effect.provideService(GitService, git),
-        Effect.provide(testLayers(repo, {})),
-      ),
-    )
-
-  it("warns about a closed run recorded by another version, slices unchanged", async () => {
-    const repo = await finishedProcess()
-    const plain = await provide(processSlices, repo)
-    const git = withTipMessage(repo, (m) =>
-      m.replace(`Gtd-Version: ${GTD_VERSION}`, "Gtd-Version: 0.0.1"),
-    )
-    const result = await slicesWith(repo, git)
-    expect(result.versionWarning).toContain("0.0.1")
-    expect(result.versionWarning).toContain(GTD_VERSION)
-    expect(result.slices).toEqual(plain.slices)
-  })
-
-  it("warns about an unknown version when the closing commit records none", async () => {
-    const repo = await finishedProcess()
-    const git = withTipMessage(repo, (m) => m.replace(/Gtd-Version: .*\n?/, ""))
-    expect((await slicesWith(repo, git)).versionWarning).toContain("an unknown gtd version")
-  })
-
-  it("does not warn for a closed run landed at the running version", async () => {
-    const repo = await finishedProcess()
-    expect((await provide(processSlices, repo)).versionWarning).toBeUndefined()
-  })
-
-  it("does not warn for an underway process", async () => {
-    const repo = repoWith(LINEAR)
-    await land(repo, { "a.txt": "a\n" })
-    const git = withTipMessage(repo, (m) =>
-      m.replace(`Gtd-Version: ${GTD_VERSION}`, "Gtd-Version: 0.0.1"),
-    )
-    expect((await slicesWith(repo, git)).versionWarning).toBeUndefined()
-  })
-
-  it("refuses on config drift before replay-ends drift", async () => {
-    const repo = await finishedProcess()
-    repo.writeFile(
-      "gtd.config.ts",
-      LINEAR.replace(
-        'await agent("checking", "check-prompt")',
-        'await agent("checking", "check-prompt")\n  await human("idle", { message: "again" })\n  await agent("polishing", "polish-prompt")',
-      ),
-    )
-    const message = await failure(repo)
-    expect(message).toContain("config differs at")
-    expect(message).not.toContain("does not end")
-  })
-
-  it("still lists an underway process's slices after the same config edit", async () => {
-    const repo = repoWith(LINEAR)
-    await land(repo, { "a.txt": "a\n" })
-    repo.writeFile("gtd.config.ts", `${LINEAR}\n// edited\n`)
-    expect((await provide(processSlices, repo)).slices).toHaveLength(1)
-  })
-})
-
 describe("summaryFor", () => {
-  const SLICED = `import { agent, human, slice, mark } from "@pmelab/gtd/flows"
+  const SUMMARISED_FLOW = `import { agent, human, mark } from "@pmelab/gtd/flows"
 
 export default async () => {
   await human("idle", { message: "idle-message" })
   mark("risk-tier", "high")
-  await slice("build", async () => {
-    await agent("building", "build-prompt")
-  })
+  await agent("building", "build-prompt")
   await human("gate", { message: "gate-message" })
-  await slice("verify", async () => {
-    await agent("checking", "check-prompt")
-  })
+  await agent("checking", "check-prompt")
 }
 
 export const summary = (it) => JSON.stringify(it)
@@ -799,197 +641,53 @@ export const summary = (it) => JSON.stringify(it)
     processCost: number
     processCostByModel: { model: string; cost: number }[]
     marks: Mark[]
-    slice?: unknown
   }
 
-  /** Entry (human, idle→building), build agent, human gate, verify agent closing. */
+  /** Entry (human, idle→building), build agent, human gate, check agent closing. */
   const finished = async () => {
-    const repo = repoWith(SLICED)
+    const repo = repoWith(SUMMARISED_FLOW)
     const boundary = headOf(repo)
     const entry = await landCost(repo, { "NOTE.md": "n\n" }, 1, "opus")
-    const built = await landCost(repo, { "a.txt": "a\n" }, 10, "opus")
+    await landCost(repo, { "a.txt": "a\n" }, 10, "opus")
     const gate = await landCost(repo, { "b.txt": "b\n" }, 100, "haiku")
     const closing = await landCost(repo, { "c.txt": "c\n" }, 1000, "haiku")
-    return { repo, boundary, entry, built, gate, closing }
+    return { repo, boundary, entry, gate, closing }
   }
-  const render = async (repo: InMemRepo, sliceName?: string) => {
+  const render = async (repo: InMemRepo) => {
     const run = await provide(summaryRun, repo)
-    const { prompt } = await provide(summaryFor(run, sliceName), repo)
+    const { prompt } = await provide(summaryFor(run), repo)
     return JSON.parse(prompt!) as Rendered
   }
 
-  it("resolves each slice with its range, 1-based index and count", async () => {
-    const { repo, boundary, built, closing } = await finished()
-    expect((await render(repo, "build")).slice).toEqual({
-      name: "build",
-      base: boundary,
-      tip: built,
-      index: 1,
-      count: 2,
-    })
-    expect((await render(repo, "verify")).slice).toEqual({
-      name: "verify",
-      base: built,
-      tip: closing,
-      index: 2,
-      count: 2,
-    })
-  })
-
-  it("renders no slice key for the plain call", async () => {
-    const { repo } = await finished()
-    expect("slice" in (await render(repo))).toBe(false)
-  })
-
-  it("narrows range and human commits to the slice's window, base exclusive and tip inclusive", async () => {
-    const { repo, boundary, built, gate, closing } = await finished()
+  it("renders the whole process: its range, human commits, cost and marks", async () => {
+    const { repo, boundary, entry, gate, closing } = await finished()
     const whole = await render(repo)
+    expect(whole.entryCommit).toBe(entry)
+    expect([whole.processBase, whole.processTip]).toEqual([boundary, closing])
     expect(whole.humanCommits.map((c) => c.hash)).toEqual([gate])
-    const build = await render(repo, "build")
-    const verify = await render(repo, "verify")
-    // the gate commit falls in the gap between the slices and folds into the later one
-    expect([build.processBase, build.processTip]).toEqual([boundary, built])
-    expect([verify.processBase, verify.processTip]).toEqual([built, closing])
-    expect(build.humanCommits).toEqual([])
-    expect(verify.humanCommits.map((c) => c.hash)).toEqual([gate])
-  })
-
-  it("splits cost by slice so the parts sum to the whole, gap commits included", async () => {
-    const { repo } = await finished()
-    const whole = await render(repo)
-    const build = await render(repo, "build")
-    const verify = await render(repo, "verify")
     expect(whole.processCost).toBe(1111)
-    expect(build.processCost + verify.processCost).toBe(whole.processCost)
-    expect(build.processCost).toBe(11)
-    expect(verify.processCost).toBe(1100)
-    const byModel = new Map<string, number>()
-    for (const part of [build, verify])
-      for (const m of part.processCostByModel)
-        byModel.set(m.model, (byModel.get(m.model) ?? 0) + m.cost)
-    expect([...byModel.entries()].sort()).toEqual(
-      whole.processCostByModel.map((m) => [m.model, m.cost] as const).sort(),
-    )
-  })
-
-  it("keeps entryCommit and marks whole-process under a slice", async () => {
-    const { repo, entry } = await finished()
-    const whole = await render(repo)
-    const verify = await render(repo, "verify")
-    expect(verify.entryCommit).toBe(entry)
-    expect(verify.entryCommit).toBe(whole.entryCommit)
-    expect(verify.marks).toEqual(whole.marks)
-    expect(verify.marks.length).toBeGreaterThan(0)
+    expect(whole.marks.length).toBeGreaterThan(0)
   })
 
-  it("refuses a named slice on an empty trace, while the plain call has nothing to render", async () => {
-    const repo = repoWith(SLICED)
+  it("has nothing to render on an empty trace", async () => {
+    const repo = repoWith(SUMMARISED_FLOW)
     const run = await provide(summaryRun, repo)
-    const exit = await provideExit(summaryFor(run, "build"), repo)
-    expect(Exit.isFailure(exit) ? String(exit.cause) : "").toContain(
-      "gtd summary: refused — HEAD neither closes nor sits inside a process",
-    )
     expect(await provide(summaryFor(run), repo)).toEqual({ prompt: undefined })
   })
 
-  it("refuses config drift at a closing HEAD with the summary prefix", async () => {
-    const { repo } = await finished()
-    const run = await provide(summaryRun, repo)
-    repo.writeFile("gtd.config.ts", `${SLICED}\n// edited\n`)
-    const exit = await provideExit(summaryFor(run, "build"), repo)
-    const message = Exit.isFailure(exit) ? String(exit.cause) : ""
-    expect(message).toContain("gtd summary: refused — config differs at")
-    expect(message).toContain("revert or stash")
-  })
-
-  it.each([
-    { recorded: GTD_VERSION, warned: false },
-    { recorded: "0.0.1", warned: true },
-  ])(
-    "refuses a closed process that does not end under today's config (recorded $recorded)",
-    async ({ recorded, warned }) => {
-      const { repo } = await finished()
-      const tip = withTipMessage(repo, (m) =>
-        m.replace(`Gtd-Version: ${GTD_VERSION}`, `Gtd-Version: ${recorded}`),
-      )
-      const run = await Effect.runPromise(
-        summaryRun.pipe(
-          Effect.provideService(GitService, tip),
-          Effect.provide(testLayers(repo, {})),
-        ),
-      )
-      repo.writeFile(
-        "gtd.config.ts",
-        SLICED.replace(
-          'await agent("checking", "check-prompt")',
-          'await agent("checking", "check-prompt")\n    await human("idle", { message: "again" })\n    await agent("polishing", "polish-prompt")',
-        ),
-      )
-      // Every ref reads as the working tree: only replay divergence remains.
-      const git: GitOperations = {
-        ...tip,
-        readFileAtRef: (_ref, path) => Effect.succeed(repo.readFile(path) ?? ""),
-      }
-      const exit = await Effect.runPromiseExit(
-        summaryFor(run, "build").pipe(
-          Effect.provideService(GitService, git),
-          Effect.provide(testLayers(repo, {})),
-        ),
-      )
-      const message = Exit.isFailure(exit) ? String(exit.cause) : ""
-      expect(message).toContain(
-        `gtd summary: refused — ${repo.resolveRef("HEAD")!.slice(0, 7)} closes a process that does not end under today's config`,
-      )
-      if (warned) expect(message).toContain(`recorded by gtd ${recorded}`)
-      else expect(message).not.toContain("recorded by gtd")
-    },
-  )
-
   it("returns no prompt, not a failure, when an edited config no longer exports a summary", async () => {
     const { repo } = await finished()
     const run = await provide(summaryRun, repo)
-    repo.writeFile("gtd.config.ts", SLICED.replace(/export const summary.*\n/, ""))
-    expect(await provide(summaryFor(run, "build"), repo)).toEqual({ prompt: undefined })
+    repo.writeFile("gtd.config.ts", SUMMARISED_FLOW.replace(/export const summary.*\n/, ""))
+    expect(await provide(summaryFor(run), repo)).toEqual({ prompt: undefined })
   })
 
-  it("plain summaryFor still returns a prompt under a config edited since the close, never replaying", async () => {
+  it("still returns a prompt under a config edited since the close, never replaying", async () => {
     const { repo } = await finished()
     const run = await provide(summaryRun, repo)
-    repo.writeFile("gtd.config.ts", `${SLICED}\n// edited\n`)
+    repo.writeFile("gtd.config.ts", `${SUMMARISED_FLOW}\n// edited\n`)
     expect((await provide(summaryFor(run), repo)).prompt).toBeDefined()
   })
-
-  it("returns a version warning for a closing commit by another gtd version, not a failure", async () => {
-    const { repo } = await finished()
-    const git = withTipMessage(repo, (m) =>
-      m.replace(`Gtd-Version: ${GTD_VERSION}`, "Gtd-Version: 0.0.1"),
-    )
-    const result = await Effect.runPromise(
-      Effect.flatMap(summaryRun, (run) => summaryFor(run, "build")).pipe(
-        Effect.provideService(GitService, git),
-        Effect.provide(testLayers(repo, {})),
-      ),
-    )
-    expect(result.versionWarning).toContain("0.0.1")
-    expect(result.prompt).toBeDefined()
-  })
-
-  it("an unknown slice name returns unknownSlice naming every slice, and keeps the version warning", async () => {
-    const { repo } = await finished()
-    const git = withTipMessage(repo, (m) =>
-      m.replace(`Gtd-Version: ${GTD_VERSION}`, "Gtd-Version: 0.0.1"),
-    )
-    const result = await Effect.runPromise(
-      Effect.flatMap(summaryRun, (run) => summaryFor(run, "nope")).pipe(
-        Effect.provideService(GitService, git),
-        Effect.provide(testLayers(repo, {})),
-      ),
-    )
-    expect(result.prompt).toBeUndefined()
-    expect(result.unknownSlice).toContain('no slice named "nope"')
-    expect(result.unknownSlice).toContain("build, verify")
-    expect(result.versionWarning).toContain("0.0.1")
-  })
 })
 
 describe("restAt", () => {

package/src/edge/Edge.ts

@@ -38,7 +38,6 @@ import {
   parseCommitMessage,
   replay,
   scopeRunStart,
-  sliceRanges,
   treeFromRecord,
   type EpisodeCommit,
   type JudgeVerdict,
@@ -46,16 +45,14 @@ import {
   type ReplayOutcome,
   type TreeView,
 } from "../replay/index.js"
-import type { Mark, ScopeAccess, SummaryContext, SummarySlice } from "../flows/index.js"
+import type { Mark, ScopeAccess, SummaryContext } from "../flows/index.js"
 import { steeringFormatFor } from "../steering/index.js"
 import {
   judgeJson,
   UNATTRIBUTED_MODEL,
   type ApprovalEntry,
   type ModelCost,
-  type SliceEntry,
   type StepAccess,
-  type StepContextLimit,
 } from "../wire/index.js"
 
 import { GTD_VERSION } from "../install/index.js"
@@ -724,13 +721,6 @@ type RequestOf<K extends ReachedStep["request"]["kind"]> = Extract<
   { kind: K }
 >
 
-const stepContext = (
-  context: { readonly soft?: number | undefined; readonly hard?: number | undefined } | undefined,
-): StepContextLimit | undefined =>
-  context === undefined
-    ? undefined
-    : { ...optional("soft", context.soft), ...optional("hard", context.hard) }
-
 const promptDef = (
   common: StepCommon,
   request: RequestOf<"agent">,
@@ -744,7 +734,6 @@ const promptDef = (
   ...optional("system", request.options.system),
   ...optional("allowEmpty", request.options.allowEmpty),
   ...optional("keep", request.options.keep),
-  ...optional("context", stepContext(request.options.context)),
   ...optional("skills", skills),
   ...optional("access", access),
 })
@@ -830,7 +819,6 @@ export interface RestHints {
   readonly mode?: string
   readonly skills?: readonly string[]
   readonly access?: StepAccess
-  readonly context?: StepContextLimit
 }
 
 const hintsOf = (def: StepDef): RestHints => ({
@@ -842,7 +830,6 @@ const hintsOf = (def: StepDef): RestHints => ({
   ...optional("mode", def.mode),
   ...optional("skills", def.skills),
   ...optional("access", def.access),
-  ...optional("context", def.context),
 })
 
 const normalizeStatus = (raw: string): ChangeStatus => (raw === "A" ? "A" : raw === "D" ? "D" : "M")
@@ -973,15 +960,6 @@ const pendingChanges = (git: GitOperations, withIndex: boolean) =>
     return [...worktree, ...(yield* git.stagedPaths()).filter((e) => !seen.has(e.path))]
   })
 
-const sliceRangesOf = (
-  slices: Parameters<typeof sliceRanges>[0],
-  run: { readonly startParentHash: string; readonly trace: readonly { readonly hash: string }[] },
-) =>
-  sliceRanges(slices, {
-    base: run.startParentHash,
-    tip: run.trace.at(-1)?.hash ?? run.startParentHash,
-  })
-
 /** Resolve the rest at `ref`, or at HEAD when `ref` is `undefined`. */
 export const restAt = (
   ref: string | undefined,
@@ -1057,99 +1035,9 @@ export const restAt = (
 
 export const currentRest: Effect.Effect<Rest, Error, RestRequirements> = restAt(undefined)
 
-export interface ProcessSlices {
-  readonly slices: readonly SliceEntry[]
-  readonly versionWarning?: string
-}
-
 type EndedOutcome = Extract<ReplayOutcome, { kind: "ended" }>
 type UnendedOutcome = Exclude<ReplayOutcome, { kind: "ended" }>
 
-/** Every slice refusal reads `<command>: refused — <reason>`; replay's own `gtd: ` lead is dropped. */
-const slicesDivergence = (command: string, run: ProcessRun, outcome: ReplayOutcome): Error => {
-  const reason =
-    outcome.kind === "rest" && run.closingHash !== undefined
-      ? `${run.closingHash.slice(0, 7)} closes a process that does not end under today's config`
-      : (replayError(outcome)?.message.replace(/^gtd: /, "") ?? "replay failed")
-  return new Error(`${command}: refused — ${reason}`)
-}
-
-/**
- * The replay `gtd slices` and `gtd summary --slice` share: the slice ranges of
- * `run`, plus whether HEAD closes it. Reads like `historyTrail`, never
- * `restAt`: it narrates and writes nothing.
- */
-const replayedSlices = (
-  config: ConfigOperations,
-  run: ProcessRun,
-  how: { readonly command: string; readonly configReason: string },
-): Effect.Effect<
-  {
-    readonly ranges: ReturnType<typeof sliceRangesOf>
-    readonly closed: boolean
-    readonly versionWarning?: string
-  },
-  Error,
-  RestRequirements
-> =>
-  Effect.gen(function* () {
-    const workspace = yield* Workspace
-    const host = yield* Host
-    if (run.trace.length === 0) {
-      return yield* Effect.fail(
-        new Error(`${how.command}: refused — HEAD neither closes nor sits inside a process`),
-      )
-    }
-    const closing = run.closingHash
-    let outcome: ReplayOutcome
-    let versionWarning: string | undefined
-    if (closing !== undefined) {
-      const replayed = yield* replayFinishedProcess(config, run, closing, {
-        command: how.command,
-        configReason: how.configReason,
-        notEnded: (o) => slicesDivergence(how.command, run, o),
-      })
-      outcome = replayed.outcome
-      versionWarning = replayed.versionWarning
-    } else {
-      const { setup } = yield* setupFor(config, run, workspace, host)
-      outcome = yield* Effect.promise(() => replayFor(setup))
-      if (outcome.kind !== "rest")
-        return yield* Effect.fail(slicesDivergence(how.command, run, outcome))
-    }
-    return {
-      ranges: sliceRangesOf(outcome.slices, run),
-      closed: closing !== undefined,
-      ...(versionWarning !== undefined ? { versionWarning } : {}),
-    }
-  })
-
-/**
- * The slices of the process HEAD closes or sits inside, current episode only,
- * stack order. Returns a version warning for a closed run.
- */
-export const processSlices: Effect.Effect<ProcessSlices, Error, RestRequirements> = Effect.gen(
-  function* () {
-    const git = yield* GitService
-    const config = yield* (yield* ConfigService).load
-    const run = yield* runAtHead(git, config.workflow)
-    const { ranges, closed, versionWarning } = yield* replayedSlices(config, run, {
-      command: "gtd slices",
-      configReason:
-        "HEAD's process replays under today's config; revert or stash the edit to list its slices",
-    })
-    return {
-      slices: ranges.map(({ name, base, tip, open }) => ({
-        name,
-        base,
-        tip,
-        closed: closed || !open,
-      })),
-      ...(versionWarning !== undefined ? { versionWarning } : {}),
-    }
-  },
-)
-
 /**
  * Whether `gtd --workflow <name>` can start a process here: the workflow must
  * reach a step from the tree the opening commit would capture. That step is
@@ -1456,24 +1344,8 @@ export const snapshotFromRest = (
 
 // ── Summary ─────────────────────────────────────────────────────────────────
 
-const narrowToSlice = (
-  run: ProcessRun,
-  slice: SummarySlice | undefined,
-): Pick<ProcessRun, "trace" | "costEntries"> => {
-  if (slice === undefined) return { trace: run.trace, costEntries: run.costEntries }
-  // `base` is exclusive: -1 when it is the episode's start parent, before the first entry.
-  const from =
-    slice.base === run.startParentHash ? -1 : run.trace.findIndex((e) => e.hash === slice.base)
-  const to = run.trace.findIndex((e) => e.hash === slice.tip)
-  const trace = run.trace.slice(from + 1, to + 1)
-  const hashes = new Set(trace.map((e) => e.hash))
-  return { trace, costEntries: run.costEntries.filter((c) => hashes.has(c.hash)) }
-}
-
 interface SummaryResult {
   readonly prompt: string | undefined
-  readonly versionWarning?: string
-  readonly unknownSlice?: string
 }
 
 const humanCommitsOf = (
@@ -1486,77 +1358,34 @@ const humanCommitsOf = (
 
 const summaryInput = (
   run: ProcessRun,
-  slice: SummarySlice | undefined,
   settings: Pick<SummaryContext, "vars" | "env">,
-) => {
+): SummaryContext => {
   const entryCommit = run.trace[0]!.hash
-  const { trace, costEntries } = narrowToSlice(run, slice)
-  const { total, byModel } = costTotals(costEntries)
+  const { total, byModel } = costTotals(run.costEntries)
   return {
     entryCommit,
-    processBase: slice?.base ?? run.startParentHash,
-    processTip: slice?.tip ?? run.trace[run.trace.length - 1]!.hash,
-    humanCommits: humanCommitsOf(trace, entryCommit),
+    processBase: run.startParentHash,
+    processTip: run.trace[run.trace.length - 1]!.hash,
+    humanCommits: humanCommitsOf(run.trace, entryCommit),
     processCost: total,
     processCostByModel: byModel,
     marks: run.marks,
     ...settings,
-    ...(slice !== undefined ? { slice } : {}),
   }
 }
 
-const locateSlice = (
-  config: ConfigOperations,
-  run: ProcessRun,
-  sliceName: string | undefined,
-): Effect.Effect<
-  | { readonly slice?: SummarySlice; readonly versionWarning?: string }
-  | { readonly unknownSlice: string; readonly versionWarning?: string },
-  Error,
-  RestRequirements
-> =>
-  Effect.gen(function* () {
-    if (sliceName === undefined) return {}
-    const replayed = yield* replayedSlices(config, run, {
-      command: "gtd summary",
-      configReason:
-        "HEAD's process replays under today's config; revert or stash the edit to summarize its slices",
-    })
-    const { ranges, versionWarning } = replayed
-    const warn = versionWarning !== undefined ? { versionWarning } : {}
-    const at = ranges.findIndex((r) => r.name === sliceName)
-    if (at < 0) {
-      return {
-        unknownSlice: `gtd summary: refused — no slice named "${sliceName}"; the slices, in stack order: ${ranges.map((r) => r.name).join(", ")}`,
-        ...warn,
-      }
-    }
-    const { base, tip } = ranges[at]!
-    return { slice: { name: sliceName, base, tip, index: at + 1, count: ranges.length }, ...warn }
-  })
-
-/**
- * A plain call never replays; under a slice, `entryCommit` and `marks` stay
- * whole-process.
- */
 export const summaryFor = (
   run: ProcessRun,
-  sliceName?: string,
 ): Effect.Effect<SummaryResult, Error, RestRequirements> =>
   Effect.gen(function* () {
     const config = yield* (yield* ConfigService).load
     const host = yield* Host
     const resolved = yield* workflowOf(config, run)
     const summary = resolved.def.summary
-    if (summary === undefined) return { prompt: undefined }
-    if (sliceName === undefined && run.trace.length === 0) return { prompt: undefined }
-    const located = yield* locateSlice(config, run, sliceName)
-    if ("unknownSlice" in located) return { prompt: undefined, ...located }
-    const { slice, versionWarning } = located
-    const prompt = summary(
-      summaryInput(run, slice, settingsFor(resolved, run.pinnedVars, host.env, {}, {})),
-    )
-    return { prompt, ...(versionWarning !== undefined ? { versionWarning } : {}) }
+    if (summary === undefined || run.trace.length === 0) return { prompt: undefined }
+    return {
+      prompt: summary(summaryInput(run, settingsFor(resolved, run.pinnedVars, host.env, {}, {}))),
+    }
   })
 
 export interface HistoryStep {