@pmelab/gtd 52.0.0 → 53.0.0

package/src/edge/index.ts

@@ -14,5 +14,4 @@ export {
   snapshotFromRest,
   summaryFor,
   historyTrail,
-  processSlices,
 } from "./Edge.js"

package/src/flows/runtime.test.ts

@@ -7,7 +7,6 @@ import {
   kept,
   mark,
   protocolMismatch,
-  slice,
   type FlowContext,
 } from "./runtime.js"
 
@@ -128,29 +127,3 @@ describe("kept()", () => {
     expect(FLOWS_PROTOCOL).toBe(1)
   })
 })
-
-describe("slice()", () => {
-  const withSlices = () => {
-    const calls: string[] = []
-    installContext({
-      enterSlice: (n: string) => calls.push(`enter ${n}`),
-      leaveSlice: () => calls.push("leave"),
-    } as unknown as FlowContext)
-    return calls
-  }
-
-  it("brackets fn with enter and leave and resolves to its value", async () => {
-    const calls = withSlices()
-    const value = await slice("refactor", async () => {
-      calls.push("fn")
-      return 42
-    })
-    expect(value).toBe(42)
-    expect(calls).toEqual(["enter refactor", "fn", "leave"])
-  })
-
-  it("runs fn unsliced on a context without enterSlice", async () => {
-    installContext(context)
-    expect(await slice("refactor", async () => "ran")).toBe("ran")
-  })
-})

package/src/flows/runtime.ts

@@ -16,18 +16,9 @@ export interface SteeringOptions {
   readonly base?: string | undefined
 }
 
-/** Shares of the model's context window at which a driver stops the turn — `gtd next --json`'s `context`. */
-export interface ContextLimitOptions {
-  /** Ask the agent to wrap up with a handoff note. Driver default 0.6. */
-  readonly soft?: number | undefined
-  /** Stop the turn outright. Driver default 0.7. */
-  readonly hard?: number | undefined
-}
-
 export interface AgentOptions extends SteeringOptions {
   readonly model?: string | undefined
   readonly system?: string | undefined
-  readonly context?: ContextLimitOptions | undefined
   /**
    * A turn that changes nothing completes the step. Without this an empty turn
    * is an attempt: recorded, but the process stays at the step (a stall).
@@ -124,8 +115,6 @@ export interface ScopeOptions {
   readonly model?: string | undefined
   /** The system prompt every agent step inside runs with, unless it sets its own. */
   readonly system?: string | undefined
-  /** The context limit every agent step inside runs with; a nested scope's or a step's own replaces it key by key. */
-  readonly context?: ContextLimitOptions | undefined
   /** The skill names every agent step inside declares — `gtd next --json`'s `skills`. A nested scope inherits it unless it sets its own. */
   readonly skills?: readonly string[] | undefined
   /** The file access every agent step inside runs with — `gtd next --json`'s `access`. A nested scope inherits it; its own replaces it wholesale. */
@@ -161,9 +150,6 @@ export interface FlowContext {
   readonly refuse: (message: string) => never
   readonly pushScope: (scope: ScopeOptions) => void
   readonly popScope: () => void
-  /** Absent on an engine older than `slice`; FLOWS_PROTOCOL stays 1. */
-  readonly enterSlice?: (name: string) => void
-  readonly leaveSlice?: () => void
   readonly read: (path: string) => string | undefined
   readonly glob: (pattern: string) => readonly string[]
   /** The last step's changes, content read on demand. */
@@ -298,21 +284,6 @@ export const scope = async <T>(scope: string | ScopeOptions, fn: () => Promise<T
   }
 }
 
-/**
- * Mark the span `fn` covers as one named slice of the process. Lands no
- * commit, prefixes no step name, opens no memory scope.
- */
-export const slice = async <T>(name: string, fn: () => Promise<T>): Promise<T> => {
-  const context = ctx()
-  if (typeof context.enterSlice !== "function") return fn()
-  context.enterSlice(name)
-  try {
-    return await fn()
-  } finally {
-    context.leaveSlice?.()
-  }
-}
-
 // ── Reads of the commit replay stands on ────────────────────────────────────
 
 export const read = (path: string): string | undefined => ctx().read(path)
@@ -501,36 +472,17 @@ export const openQuestions = (text: string): readonly OpenQuestion[] => ctx().op
 /** A workflow's one flow. */
 export type Flow = () => Promise<void>
 
-/** The slice `gtd summary --slice` writes the closing message for. */
-export interface SummarySlice {
-  readonly name: string
-  /** Exclusive, as in git's `base..tip`. */
-  readonly base: string
-  readonly tip: string
-  /** 1-based stack position: `index === count` is the last slice. */
-  readonly index: number
-  readonly count: number
-}
-
 export interface SummaryContext {
-  /** Whole process, even under a slice. */
   readonly entryCommit: string
-  /** The slice's `base` under `--slice`. */
   readonly processBase: string
-  /** The slice's `tip` under `--slice`. */
   readonly processTip: string
-  /** The slice's own under `--slice`. */
   readonly humanCommits: readonly { readonly hash: string; readonly state: string }[]
-  /** The slice's own under `--slice`. */
   readonly processCost: number
-  /** The slice's own under `--slice`. */
   readonly processCostByModel: readonly { readonly model: string; readonly cost: number }[]
-  /** Every `Gtd-Mark` of the process's commits, oldest first — whole process, even under a slice. */
+  /** Every `Gtd-Mark` of the process's commits, oldest first. */
   readonly marks: readonly Mark[]
   readonly vars: Readonly<Record<string, string>>
   readonly env: Readonly<Record<string, string>>
-  /** Present only under `gtd summary --slice`; the key is absent, not undefined, otherwise. */
-  readonly slice?: SummarySlice
 }
 
 /** `gtd summary`'s prompt — a workflow module's optional `summary` export. */

package/src/install/Install.ts

@@ -81,10 +81,7 @@ while :; do
       model="$(gtd next --json=model)"
       system="$(gtd next --json=system)"
       validate="$(gtd next --json=validate)"
-      context="$(gtd next --json=context)"
       log="$(gtd next --json=log)"
-      # Absolute, since the hook runs wherever the agent last cd'ed to.
-      case "$log" in /*) ;; *) log="$(git rev-parse --show-toplevel)/$log" ;; esac
       # \`model\` is a hint, not a model name — the bundled workflow ships
       # \`smart\` and \`base\`, which \`claude --model\` rejects. Resolve them
       # from your environment; unset, the hint is dropped and the agent runs
@@ -93,18 +90,6 @@ while :; do
         smart) model="\${GTD_LOOP_MODEL_SMART:-}" ;;
         base) model="\${GTD_LOOP_MODEL_BASE:-}" ;;
       esac
-      # The step's context limit, as a Claude Code hook after every tool
-      # call and before compacting. Past \`hard\` it stops the turn and
-      # appends why to the stop file, so we land nothing and stop too.
-      soft="$(printf '%s' "$context" | sed -n 's/.*"soft":\\([0-9.]*\\).*/\\1/p')"
-      hard="$(printf '%s' "$context" | sed -n 's/.*"hard":\\([0-9.]*\\).*/\\1/p')"
-      window="\${GTD_LOOP_CONTEXT_WINDOW:-}"
-      case "$model" in *'[1m]'* | *'[1M]'*) window="\${window:-1000000}" ;; esac
-      hook="gtd context-hook\${soft:+ --soft $soft}\${hard:+ --hard $hard}\${window:+ --window $window}"
-      hooks="[{\\"hooks\\":[{\\"type\\":\\"command\\",\\"command\\":\\"$hook\\"}]}]"
-      settings="{\\"hooks\\":{\\"PostToolUse\\":$hooks,\\"PreCompact\\":$hooks}}"
-      stop="$log.context-stop"
-      rm -f "$stop"
       # One turn, its prompt on stdin. The prompt embeds a full diff, so it
       # never goes on argv — argv is capped (~1 MB on macOS, and POSIX
       # guarantees only 4 KB, ARG_MAX), and a diff crosses that far sooner
@@ -112,15 +97,15 @@ while :; do
       # whether \`claude --resume\` re-applies the original session's is a
       # harness detail gtd cannot verify from outside. Its JSON envelope
       # goes to the log, and its \`total_cost_usd\` adds up into $cost. An
-      # \`is_error\` envelope (max turns, an error mid-turn) or one another
-      # hook stopped fails the turn even at exit 0: landing it would land
-      # the failure as work. Only a turn that never ran (no envelope: the
+      # \`is_error\` envelope (max turns, an error mid-turn) or one a hook
+      # stopped fails the turn even at exit 0: landing it would land the
+      # failure as work. Only a turn that never ran (no envelope: the
       # session flag was refused) is worth retrying under the other flag.
       turn() {
-        out="$(GTD_LOOP_CONTEXT_STOP_FILE="$stop" claude -p "$@" \\
+        out="$(claude -p "$@" \\
           \${model:+--model "$model"} \\
           \${system:+--system-prompt "$system"} \\
-          --settings "$settings" --output-format json \\
+          --output-format json \\
           --dangerously-skip-permissions 2>>"$log")" && ok=0 || ok=$?
         printf '%s\\n' "$out" >>"$log"
         case "$out" in *'"type":"result"'*) ran=true ;; *) ran=false ;; esac
@@ -130,10 +115,6 @@ while :; do
         usd="$(printf '%s\\n' "$out" | sed -n 's/.*"total_cost_usd":\\([0-9.eE+-]*\\).*/\\1/p' | tail -n 1)"
         [ -z "$usd" ] || cost="$(awk -v a="\${cost:-0}" -v b="$usd" 'BEGIN { printf "%.6f", a + b }')"
         [ "\${cost:-}" != 0.000000 ] || cost=
-        if [ -s "$stop" ]; then
-          cat "$stop" >&2
-          exit 1
-        fi
         return "$ok"
       }
       # Plain \`gtd next\` (not --json=content) renders the diff once.
@@ -619,6 +600,16 @@ way — an existing \`gtd-loop\` survives untouched beside the new
 \`gtd-door review [base]\`). When either is still present beside the suite,
 name it to the user as superseded and ask before removing it — never remove
 one unasked.
+
+An older \`gtd-build\` passed a \`gtd context-hook\` hook to every turn, and
+an older setup guide had it registered in Claude Code's own settings
+(\`PostToolUse\`/\`PreCompact\`). That command no longer exists: a hook
+still calling it fails on every tool call. Replace such a \`gtd-build\` as a
+differing file above, and look for a \`gtd context-hook\` entry in the user's
+Claude Code settings files (\`~/.claude/settings.json\`, the repository's
+\`.claude/settings.json\` and \`.claude/settings.local.json\`): name each file
+to the user, then remove that entry alone, leaving every other key
+byte-identical.
 `
 
 const EDITOR_INTEGRATION = `

package/src/replay/Replay.test.ts

@@ -15,7 +15,6 @@ import {
   restart,
   run,
   scope,
-  slice,
   threads,
   type Flow,
   type ScopeAccess,
@@ -1207,171 +1206,3 @@ describe("human({ approve })", () => {
     expect(outcome.kind).toBe("rest")
   })
 })
-
-describe("slice()", () => {
-  const spansOf = (o: ReplayOutcome) => (o as { slices: unknown }).slices
-
-  it("records enteredAt and leftAt as the commit replay stood on", async () => {
-    const wf = async () => {
-      await human("a")
-      await slice("refactor", async () => {
-        await human("b")
-      })
-      await human("c")
-    }
-    const h = new History().land("human", "a", 1, "b").land("human", "b", 1, "c")
-    const outcome = await replayOf(wf, h)
-    expect(outcome).toMatchObject({ kind: "rest" })
-    expect(spansOf(outcome)).toEqual([
-      { name: "refactor", enteredAt: hashOf(1), leftAt: hashOf(2) },
-    ])
-  })
-
-  it("an ended outcome carries every span of the episode that just ended", async () => {
-    const wf = async () => {
-      await slice("one", async () => {
-        await human("a")
-      })
-      await slice("two", async () => {
-        await human("b")
-      })
-    }
-    const h = new History().land("human", "a", 1, "b").land("human", "b", 1, "done")
-    const outcome = await replayOf(wf, h)
-    expect(outcome).toMatchObject({ kind: "ended", via: "return" })
-    expect(spansOf(outcome)).toEqual([
-      { name: "one", enteredAt: hashOf(0), leftAt: hashOf(1) },
-      { name: "two", enteredAt: hashOf(1), leftAt: hashOf(2) },
-    ])
-  })
-
-  it("restart() inside a slice ends via restart with that span's leftAt undefined", async () => {
-    const wf = async () => {
-      await human("a")
-      await slice("risky", async () => {
-        await human("b")
-        await restart()
-      })
-    }
-    const h = new History().land("human", "a", 1, "b").land("human", "b", 1, "done")
-    const outcome = await replayOf(wf, h)
-    expect(outcome).toMatchObject({ kind: "ended", via: "restart" })
-    expect(spansOf(outcome)).toEqual([{ name: "risky", enteredAt: hashOf(1), leftAt: undefined }])
-  })
-
-  it("keeps leftAt undefined when the process rests inside the slice", async () => {
-    const wf = async () => {
-      await slice("refactor", async () => {
-        await human("a")
-      })
-    }
-    const outcome = await replayOf(wf, new History())
-    expect(spansOf(outcome)).toEqual([
-      { name: "refactor", enteredAt: hashOf(0), leftAt: undefined },
-    ])
-  })
-
-  it("records enteredAt === leftAt for a slice that landed no commit", async () => {
-    const wf = async () => {
-      await human("a")
-      await slice("empty", async () => undefined)
-      await human("b")
-    }
-    const h = new History().land("human", "a", 1, "b")
-    expect(spansOf(await replayOf(wf, h))).toEqual([
-      { name: "empty", enteredAt: hashOf(1), leftAt: hashOf(1) },
-    ])
-  })
-
-  it("prefixes no step name and ignores an enclosing scope", async () => {
-    const wf = async () => {
-      await scope("build", async () => {
-        await slice("refactor", async () => {
-          await human("gate")
-        })
-      })
-    }
-    const outcome = await replayOf(wf, new History())
-    expect(outcome).toMatchObject({ kind: "rest", rest: { name: "build.gate" } })
-    expect((spansOf(outcome) as { name: string }[])[0]!.name).toBe("refactor")
-  })
-
-  const failed = async (wf: Flow) => {
-    const outcome = await replayOf(wf, new History())
-    expect(outcome.kind).toBe("failed")
-    return (outcome as { message: string }).message
-  }
-
-  it.each(["Refactor", "step_1", "v2.api", ""])("refuses the name %j", async (name) => {
-    expect(await failed(async () => slice(name, async () => human("a")))).toBe(
-      `gtd: slice "${name}": name must match /^[a-z][a-z0-9-]*$/`,
-    )
-  })
-
-  it("accepts refactor-2", async () => {
-    const outcome = await replayOf(
-      async () => slice("refactor-2", async () => human("a")),
-      new History(),
-    )
-    expect(outcome.kind).toBe("rest")
-  })
-
-  it("refuses the reserved name main", async () => {
-    expect(await failed(async () => slice("main", async () => human("a")))).toBe(
-      'gtd: slice "main" is reserved for the implicit slice',
-    )
-  })
-
-  it("refuses nesting, also through scope()", async () => {
-    const message = 'gtd: slice "inner" is entered inside slice "outer" — slices do not nest'
-    expect(
-      await failed(async () => slice("outer", async () => slice("inner", async () => human("a")))),
-    ).toBe(message)
-    expect(
-      await failed(async () =>
-        slice("outer", async () => scope("s", async () => slice("inner", async () => human("a")))),
-      ),
-    ).toBe(message)
-  })
-
-  it("checks the name rule before main and nesting", async () => {
-    expect(
-      await failed(async () => slice("outer", async () => slice("Main", async () => human("a")))),
-    ).toBe('gtd: slice "Main": name must match /^[a-z][a-z0-9-]*$/')
-  })
-
-  it("lets a flow that caught an error from a slice enter another", async () => {
-    const wf = async () => {
-      try {
-        await slice("a", async () => {
-          throw new Error("boom")
-        })
-      } catch {}
-      await slice("b", async () => human("x"))
-    }
-    expect(await replayOf(wf, new History())).toMatchObject({ kind: "rest" })
-  })
-
-  it("refuses a non-string name", async () => {
-    expect(
-      await failed(async () => slice(undefined as unknown as string, async () => human("a"))),
-    ).toContain("name must match")
-  })
-
-  it("refuses a name entered twice, sequentially and from a loop", async () => {
-    const message =
-      'gtd: slice "again" is entered twice in this episode — a loop must sit inside its slice'
-    expect(
-      await failed(async () => {
-        await slice("again", async () => undefined)
-        await slice("again", async () => human("a"))
-      }),
-    ).toBe(message)
-    expect(
-      await failed(async () => {
-        for (let i = 0; i < 2; i++) await slice("again", async () => undefined)
-        await human("a")
-      }),
-    ).toBe(message)
-  })
-})

package/src/replay/Replay.ts

@@ -8,7 +8,6 @@ import {
   type ScopeAccess,
   type AccessDef,
   type ScopeOptions,
-  type ContextLimitOptions,
   type StepRequest,
   type Flow,
   type Mark,
@@ -22,9 +21,8 @@ import {
   unansweredQuestions,
 } from "../steering/index.js"
 import { accessShapeFault, foldAccess, sameAccess } from "./Access.js"
-import { contextLimitFault, contextShapeFault, globMatches } from "../wire/index.js"
+import { globMatches } from "../wire/index.js"
 import { refNameFault } from "./RefName.js"
-import { IMPLICIT_SLICE, SLICE_NAME, type SliceSpan } from "./Slices.js"
 import { diffTrees, isEmptyDiff, type TreeView } from "./Tree.js"
 import {
   formatStepId,
@@ -119,7 +117,6 @@ export type ReplayOutcome =
       readonly landed: ReachedStep | undefined
       /** Marks the flow made after the pending turn's step resolved; [] without a pending turn. */
       readonly marks: readonly Mark[]
-      readonly slices: readonly SliceSpan[]
     }
   | {
       readonly kind: "ended"
@@ -127,8 +124,6 @@ export type ReplayOutcome =
       readonly trace: readonly ReachedStep[]
       readonly landed: ReachedStep | undefined
       readonly marks: readonly Mark[]
-      /** Spans of the episode that just ended; a restart() inside a slice leaves its leftAt undefined. */
-      readonly slices: readonly SliceSpan[]
     }
   | { readonly kind: "divergence"; readonly message: string }
   | { readonly kind: "refused"; readonly message: string }
@@ -238,28 +233,6 @@ const budgeted = (
   return { evidence: bounded, truncated }
 }
 
-// The innermost of `chain`, named by its full path.
-const scopeLabel = (chain: readonly ScopeOptions[]): string => {
-  const path = chain.flatMap((o) => (o.name === undefined ? [] : [o.name])).join(".")
-  if (chain.at(-1)?.name !== undefined) return `scope "${path}"`
-  return path === "" ? "an unnamed scope" : `an unnamed scope inside "${path}"`
-}
-
-// Key by key, innermost last: a scope or step that sets only `hard` keeps the outer `soft`.
-const inheritedContext = (
-  layers: readonly (ContextLimitOptions | undefined)[],
-): ContextLimitOptions | undefined =>
-  layers.reduce<ContextLimitOptions | undefined>(
-    (merged, layer) =>
-      layer === undefined
-        ? merged
-        : {
-            ...merged,
-            ...Object.fromEntries(Object.entries(layer).filter(([, value]) => value !== undefined)),
-          },
-    undefined,
-  )
-
 interface Identity {
   readonly model: string | undefined
   readonly system: string | undefined
@@ -296,7 +269,7 @@ const STEERING_OPTIONS = ["file", "mode", "label", "base"]
 // The option keys each step accepts. A gtd.config.ts is evaluated without a
 // type check, so a misspelt key would otherwise be silently ignored.
 const KNOWN_OPTIONS: Readonly<Record<StepKind, ReadonlySet<string>>> = {
-  agent: new Set([...STEERING_OPTIONS, "model", "system", "context", "allowEmpty", "keep"]),
+  agent: new Set([...STEERING_OPTIONS, "model", "system", "allowEmpty", "keep"]),
   human: new Set([...STEERING_OPTIONS, "message", "acceptClean", "approve"]),
   run: new Set(STEERING_OPTIONS),
   judge: new Set([...STEERING_OPTIONS, "message"]),
@@ -354,7 +327,6 @@ export const replay = async (input: ReplayInput): Promise<ReplayOutcome> => {
   >()
   let landed: ReachedStep | undefined
   const marks: Mark[] = []
-  const slices: { name: string; enteredAt: string; leftAt: string | undefined }[] = []
   let outcome: ReplayOutcome | undefined
   let signal: (() => void) | undefined
   const settled = new Promise<void>((resolve) => {
@@ -479,15 +451,7 @@ export const replay = async (input: ReplayInput): Promise<ReplayOutcome> => {
         if (s.model !== undefined) persona.model = s.model
         if (s.system !== undefined) persona.system = s.system
       }
-      const context = inheritedContext([...scopes.map((s) => s.context), request.options.context])
-      return {
-        ...request,
-        options: {
-          ...persona,
-          ...request.options,
-          ...(context === undefined ? {} : { context }),
-        },
-      }
+      return { ...request, options: { ...persona, ...request.options } }
     }
     if (request.kind === "judge") {
       const { evidence, truncated } = budgeted(request.evidence, input.budgetBytes)
@@ -626,34 +590,11 @@ export const replay = async (input: ReplayInput): Promise<ReplayOutcome> => {
         trace,
         landed,
         marks,
-        slices: slices.map((s) => ({ ...s })),
       })
     }
     return landPending(step, input.pending)
   }
 
-  // Each layer on its own first, so a bad scope or workflow option is named as
-  // such rather than blamed on the step it reached; then the merged limit.
-  const scopeContextFault = (): string | undefined => {
-    for (const [i, s] of scopes.entries()) {
-      const fault = s.context === undefined ? undefined : contextShapeFault(s.context)
-      if (fault !== undefined)
-        return `the context of ${scopeLabel(scopes.slice(0, i + 1))}: ${fault}`
-    }
-    return undefined
-  }
-
-  const resolvedContextFault = (
-    request: Extract<StepRequest, { kind: "agent" }>,
-  ): string | undefined => {
-    const own = request.options.context
-    const layered = scopeContextFault() ?? (own === undefined ? undefined : contextShapeFault(own))
-    if (layered !== undefined) return layered
-    const resolved = resolve(request)
-    const context = resolved.kind === "agent" ? resolved.options.context : undefined
-    return context === undefined ? undefined : contextLimitFault(context)
-  }
-
   // gtd.config.ts is loaded without a type check.
   const requestFault = (request: Exclude<StepRequest, { kind: "restart" }>): string | undefined => {
     if (request.kind === "run" && typeof request.body !== "string") {
@@ -661,8 +602,6 @@ export const replay = async (input: ReplayInput): Promise<ReplayOutcome> => {
     }
     if (request.kind !== "agent") return undefined
     const name = scoped(request.name)
-    const contextFault = resolvedContextFault(request)
-    if (contextFault !== undefined) return `gtd: step "${name}": ${contextFault}`
     if (request.options.keep === true) {
       // A clean allowEmpty keep would land an ordinary commit with no Gtd-Kept: a silent skip.
       if (request.options.allowEmpty === true) {
@@ -696,7 +635,7 @@ export const replay = async (input: ReplayInput): Promise<ReplayOutcome> => {
           kind: "divergence",
           message: `gtd: the flow ended, but commit ${short(commits[cursor]!.hash)} continues the episode — ${DIVERGED}`,
         }
-      : { kind: "ended", via, trace, landed, marks, slices: slices.map((s) => ({ ...s })) }
+      : { kind: "ended", via, trace, landed, marks }
 
   const changesSince = (hash: string): readonly Change[] => {
     const tree = treeAt(hash)
@@ -723,34 +662,6 @@ export const replay = async (input: ReplayInput): Promise<ReplayOutcome> => {
       scopes.pop()
       scopeCallIds.pop()
     },
-    enterSlice: (name) => {
-      if (outcome !== undefined) return
-      const fail = (message: string): never => {
-        void finish({ kind: "failed", message })
-        throw new Stop()
-      }
-      if (typeof name !== "string" || !SLICE_NAME.test(name)) {
-        fail(`gtd: slice "${name}": name must match ${SLICE_NAME}`)
-      }
-      if (name === IMPLICIT_SLICE) {
-        fail(`gtd: slice "${IMPLICIT_SLICE}" is reserved for the implicit slice`)
-      }
-      const open = slices.find((s) => s.leftAt === undefined)
-      if (open !== undefined) {
-        fail(`gtd: slice "${name}" is entered inside slice "${open.name}" — slices do not nest`)
-      }
-      if (slices.some((s) => s.name === name)) {
-        fail(
-          `gtd: slice "${name}" is entered twice in this episode — a loop must sit inside its slice`,
-        )
-      }
-      slices.push({ name, enteredAt: position.hash, leftAt: undefined })
-    },
-    leaveSlice: () => {
-      if (outcome !== undefined) return
-      const open = slices.find((s) => s.leftAt === undefined)
-      if (open !== undefined) open.leftAt = position.hash
-    },
     read: (path) => position.tree.read(path),
     glob: (pattern) => position.tree.paths().filter((path) => globMatches(path, pattern)),
     changes: () => changesBetween(previousPosition.tree, position.tree),

package/src/replay/index.ts

@@ -18,4 +18,3 @@ export {
 export { accessShapeFault, foldAccess } from "./Access.js"
 export { formatFault } from "./Format.js"
 export { refNameFault } from "./RefName.js"
-export { sliceRanges } from "./Slices.js"

package/src/testkit/Layers.ts

@@ -205,7 +205,6 @@ const missingTool = (name: string) => () =>
 const missingToolCommands: ToolCommands["Type"] = {
   ui: missingTool("ui"),
   lsp: missingTool("lsp"),
-  contextHook: missingTool("context-hook"),
   judge: () =>
     Promise.reject(
       new Error("gtd judge run: ToolCommands has no test double wired into testLayers()"),

package/src/testkit/steps.ts

@@ -149,6 +149,10 @@ Given("the working tree is committed as {string}", (world: TestkitWorld, message
   world.repo().commit(message)
 })
 
+Given("the working tree is committed with the message:", (world: TestkitWorld, message: string) => {
+  world.repo().commit(message)
+})
+
 Given("step {string} changes nothing", (world: TestkitWorld, step: string) => {
   world.act(step, () => undefined)
 })
@@ -180,6 +184,15 @@ Given(
   },
 )
 
+Given(
+  "step {string} appends to {string}:",
+  (world: TestkitWorld, step: string, path: string, text: string) => {
+    world.act(step, (_, repo) => {
+      repo.write(path, `${(repo.read(path) ?? "").trimEnd()}\n\n${withNewline(text)}`)
+    })
+  },
+)
+
 Given("step {string} deletes {string}", (world: TestkitWorld, step: string, path: string) => {
   world.act(step, (_, repo) => repo.remove(path))
 })

package/src/wire/BeatDocument.ts

@@ -1,14 +1,6 @@
 import type { BeatKind, Demand, DemandSession } from "./Demand.js"
 import type { BeatStatus, NextMatch, StatusChange } from "./BeatStatus.js"
-import type {
-  Actor,
-  ApprovalEntry,
-  ModelCost,
-  StateMode,
-  StateName,
-  StepAccess,
-  StepContextLimit,
-} from "./types.js"
+import type { Actor, ApprovalEntry, ModelCost, StateMode, StateName, StepAccess } from "./types.js"
 import { WIRE_SCHEMA } from "./constants.js"
 
 /** `gtd next --json`'s `next` key — `null` when landing would commit nothing. */
@@ -64,7 +56,6 @@ export interface BeatDocument {
   readonly session: DemandSession | undefined
   readonly model: string | undefined
   readonly system: string | undefined
-  readonly context: StepContextLimit | undefined
   readonly validate: string | undefined
   readonly log: string
   readonly state: StateName
@@ -85,7 +76,7 @@ export interface BeatDocument {
 }
 
 /**
- * Flatten a `Demand` plus its `BeatStatus` into the single 26-key document
+ * Flatten a `Demand` plus its `BeatStatus` into the single 25-key document
  * `gtd next --json` emits — the ONLY place the two are joined. `cost`/
  * `costByModel` are omitted together, exactly when no cost was recorded
  * (`cost <= 0`).
@@ -102,7 +93,6 @@ export const beatDocument = (demand: Demand, status: BeatStatus): BeatDocument =
     session,
     model: status.model,
     system: status.system,
-    context: status.context,
     validate,
     log: status.log,
     state: status.state,