@pmelab/gtd 52.0.0 → 53.0.0

package/src/replay/Slices.test.ts

@@ -1,73 +0,0 @@
-import { describe, expect, it } from "vitest"
-import { sliceRanges, type SliceSpan } from "./Slices.js"
-
-const span = (name: string, enteredAt: string, leftAt?: string): SliceSpan => ({
-  name,
-  enteredAt,
-  leftAt,
-})
-const running = { base: "B", tip: "T" }
-
-describe("sliceRanges", () => {
-  it("two adjacent spans: first from episode.base to its leftAt, second from there to episode.tip", () => {
-    expect(sliceRanges([span("a", "B", "c2"), span("b", "c2", "T")], running)).toEqual([
-      { name: "a", base: "B", tip: "c2", open: false },
-      { name: "b", base: "c2", tip: "T", open: true },
-    ])
-  })
-
-  it("a leading gap folds into the first range via episode.base", () => {
-    expect(sliceRanges([span("a", "c1", "c2")], running)).toEqual([
-      { name: "a", base: "B", tip: "T", open: true },
-    ])
-  })
-
-  it("an inner gap folds into the next range: its base is the previous leftAt", () => {
-    expect(sliceRanges([span("a", "B", "c1"), span("b", "c3", "T")], running)).toEqual([
-      { name: "a", base: "B", tip: "c1", open: false },
-      { name: "b", base: "c1", tip: "T", open: true },
-    ])
-  })
-
-  it("a trailing gap folds back: the last range's tip is the episode tip, and it stays open", () => {
-    expect(sliceRanges([span("a", "B", "c1")], running)).toEqual([
-      { name: "a", base: "B", tip: "T", open: true },
-    ])
-  })
-
-  it("drops a closed empty span, first, middle and last, its neighbours absorbing the gap", () => {
-    expect(sliceRanges([span("e", "B", "B"), span("a", "B", "c1")], running)).toEqual([
-      { name: "a", base: "B", tip: "T", open: true },
-    ])
-    expect(
-      sliceRanges([span("a", "B", "c1"), span("e", "c2", "c2"), span("b", "c2", "c4")], running),
-    ).toEqual([
-      { name: "a", base: "B", tip: "c1", open: false },
-      { name: "b", base: "c1", tip: "T", open: true },
-    ])
-    expect(sliceRanges([span("a", "B", "c1"), span("e", "c1", "c1")], running)).toEqual([
-      { name: "a", base: "B", tip: "T", open: true },
-    ])
-  })
-
-  it("no spans, and only empty closed spans, each yield one open main range over the whole episode", () => {
-    const main = [{ name: "main", base: "B", tip: "T", open: true }]
-    expect(sliceRanges([], running)).toEqual(main)
-    expect(sliceRanges([span("e", "c1", "c1")], running)).toEqual(main)
-  })
-
-  it("an unleft empty span is kept and open", () => {
-    expect(sliceRanges([span("a", "B", "c1"), span("b", "c1")], running)).toEqual([
-      { name: "a", base: "B", tip: "c1", open: false },
-      { name: "b", base: "c1", tip: "T", open: true },
-    ])
-    expect(sliceRanges([span("b", "T")], running)).toEqual([
-      { name: "b", base: "B", tip: "T", open: true },
-    ])
-  })
-
-  it("rejects a pending turn's empty hash", () => {
-    expect(() => sliceRanges([span("a", "", "c1")], running)).toThrow("not a commit")
-    expect(() => sliceRanges([span("a", "c1", "")], running)).toThrow("not a commit")
-  })
-})

package/src/replay/Slices.ts

@@ -1,45 +0,0 @@
-export const IMPLICIT_SLICE = "main"
-
-/** Same shape as mark()'s name rule; kept local so @pmelab/gtd/flows publishes no regex. */
-export const SLICE_NAME = /^[a-z][a-z0-9-]*$/
-
-/** One slice() call as replay saw it. Hashes are the commit replay stood on; "" is a pending turn. */
-export interface SliceSpan {
-  readonly name: string
-  readonly enteredAt: string
-  /** undefined: the flow never left it — the process rests inside, or restart() fired inside. */
-  readonly leftAt: string | undefined
-}
-
-export interface SliceRange {
-  readonly name: string
-  /** Exclusive: the range is base..tip in git's sense. */
-  readonly base: string
-  readonly tip: string
-  /** The tip can still move: only the last range, since a rest is never past the episode's end. */
-  readonly open: boolean
-}
-
-/**
- * Folds boundaries into ranges: each kept span's base is the previous kept
- * span's `leftAt`, so a gap before a span belongs to it, and the last span
- * runs to the episode tip. A closed span that landed nothing is dropped.
- */
-export const sliceRanges = (
-  spans: readonly SliceSpan[],
-  episode: { readonly base: string; readonly tip: string },
-): readonly SliceRange[] => {
-  if (spans.some((s) => s.enteredAt === "" || s.leftAt === "")) {
-    throw new Error('sliceRanges: a pending turn\'s "" hash is not a commit')
-  }
-  const kept = spans.filter((s) => s.leftAt === undefined || s.enteredAt !== s.leftAt)
-  if (kept.length === 0) {
-    return [{ name: IMPLICIT_SLICE, base: episode.base, tip: episode.tip, open: true }]
-  }
-  return kept.map((s, i) => ({
-    name: s.name,
-    base: i === 0 ? episode.base : (kept[i - 1]!.leftAt ?? episode.base),
-    tip: i === kept.length - 1 ? episode.tip : (s.leftAt ?? episode.tip),
-    open: i === kept.length - 1,
-  }))
-}

package/src/wire/ContextLimit.fixture.ts

@@ -1,30 +0,0 @@
-/** A Claude Code transcript whose latest assistant message used `tokens` of context, as the hook reads it from `transcript_path`. */
-export const transcriptAt = (tokens: number): string =>
-  [
-    { type: "user", message: { role: "user", content: "build it" } },
-    {
-      type: "assistant",
-      message: {
-        id: "msg_1",
-        role: "assistant",
-        usage: { input_tokens: 3, cache_read_input_tokens: 10, cache_creation_input_tokens: 7 },
-      },
-    },
-    { type: "user", message: { role: "user", content: [{ type: "tool_result" }] } },
-    {
-      type: "assistant",
-      message: {
-        id: "msg_2",
-        role: "assistant",
-        usage: {
-          input_tokens: 1,
-          cache_read_input_tokens: tokens - 1001,
-          cache_creation_input_tokens: 1000,
-          output_tokens: 500,
-        },
-      },
-    },
-    { type: "attachment", attachment: { type: "hook_success" } },
-  ]
-    .map((entry) => JSON.stringify(entry))
-    .join("\n") + "\n"

package/src/wire/ContextLimit.test.ts

@@ -1,96 +0,0 @@
-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

@@ -1,169 +0,0 @@
-// The context-limit decision every driver shares: `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. Where your instructions name a file for that note, write it there too.`,
-    }
-  }
-  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/Slices.ts

@@ -1,25 +0,0 @@
-import { WIRE_SCHEMA } from "./constants.js"
-
-export interface SliceEntry {
-  readonly name: string
-  /** Full hash, exclusive: git's base..tip. */
-  readonly base: string
-  /** Full hash, inclusive; HEAD's hash for the open slice. */
-  readonly tip: string
-  /** false only for the last slice of an underway process. */
-  readonly closed: boolean
-}
-
-export interface SlicesDocument {
-  readonly schema: number
-  readonly slices: readonly SliceEntry[]
-}
-
-/** The ONLY place `gtd slices --json`'s shape is built; copies exactly the four fields, in order. */
-export const slicesDocument = (slices: readonly SliceEntry[]): SlicesDocument => ({
-  schema: WIRE_SCHEMA,
-  slices: slices.map(({ name, base, tip, closed }) => ({ name, base, tip, closed })),
-})
-
-export const renderSlicesJson = (document: SlicesDocument): string =>
-  JSON.stringify(document) + "\n"

package/src/wire/golden/1/slices.json

@@ -1,11 +0,0 @@
-{
-  "schema": 1,
-  "slices": [
-    {
-      "name": "build",
-      "base": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
-      "tip": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
-      "closed": true
-    }
-  ]
-}

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

@@ -1,37 +0,0 @@
-@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/continuation-cap.feature

@@ -1,65 +0,0 @@
-@inmem
-Feature: past its continuation cap a phase rests for a person
-
-  With `continuations` at 1, a naive pass stopped at its context limit gets
-  one continuation; when that one stops too, `seam.oversized` asks a person,
-  and landing there grants a fresh round.
-
-  Background:
-    Given the shipped workflows, as gtd install scaffolds them
-    And an environment variable "GTD_CONTINUATIONS" set to "1"
-    And an environment variable "GTD_QUALITYREVIEWS" set to ""
-    And an environment variable "GTD_REFACTORQUALITYREVIEWS" set to ""
-    And an environment variable "GTD_FLAG_RISK_TIER" set to "0"
-    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 and multiply
-      """
-    And step "unwind" changes nothing
-    And step "start-gate.check" changes nothing
-    And step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
-      """
-      # Requirements
-
-      ## Acceptance Criteria
-
-      - AC-1: `subtract(5, 3)` returns 2.
-      - AC-2: `multiply(2, 3)` returns 6.
-      """
-    And step "design.gate.answer" changes nothing
-    And step "seam.check" changes nothing
-
-  Scenario: past the continuation cap the naive pass rests for a person, and landing there grants a new round
-    Given step "seam.naive" writes ".gtd/HANDOFF.md" with:
-      """
-      Roughed out subtract.
-      """
-    And step "seam.continue.naive" writes "tests/calc.test.ts" with:
-      """
-      it("[AC-1] subtracts", () => {})
-      """
-    And step "seam.continue.naive" writes ".gtd/HANDOFF.md" with:
-      """
-      Subtract is tested; multiply was next.
-      """
-    When the process is driven
-    Then the process rests at "seam.oversized"
-    And the resting step's content contains "1 continuation ran and the last still stopped at its context limit"
-    And the resting step's content contains "still open: AC-2"
-
-    When gtd lands
-    Then the process rests at "seam.continue.naive"
-    And the resting step's content contains "Still open: AC-2."
-    And the commit subjects end with:
-      """
-      gtd(human): design.gate.answer → seam.naive
-      gtd(agent): seam.naive → seam.continue.naive
-      gtd(agent): seam.continue.naive → seam.oversized
-      gtd(human): seam.oversized → seam.continue.naive
-      """
-

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

@@ -1,88 +0,0 @@
-@inmem
-Feature: a rebuild stopped at its context limit is continued on the branch
-
-  The rebuild's snapshot is its own commit: the continuation finds the work
-  in the tree, and the health loop greens the whole build afterwards.
-  `seamAllow` is empty here, so the naive pass's change to an existing test
-  file is the judge's only stray and refactor-first rebuilds with no refactor.
-
-  Background:
-    Given the shipped workflows, as gtd install scaffolds them
-    And an environment variable "GTD_SEAMALLOW" set to ""
-    And an environment variable "GTD_QUALITYREVIEWS" set to ""
-    And an environment variable "GTD_REFACTORQUALITYREVIEWS" set to ""
-    And an environment variable "GTD_FLAG_RISK_TIER" set to "0"
-    And a file "src/calc.ts" with:
-      """
-      export const add = (a: number, b: number) => a + b
-      """
-    And a file "tests/calc.test.ts" with:
-      """
-      it("adds", () => {})
-      """
-    And the working tree is committed as "feat: add calculator"
-    And a file "TODO.md" with:
-      """
-      # Add subtract and multiply
-      """
-    And step "unwind" changes nothing
-    And step "start-gate.check" changes nothing
-    And step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
-      """
-      # Requirements
-
-      ## Acceptance Criteria
-
-      - AC-1: `subtract(5, 3)` returns 2.
-      - AC-2: `multiply(2, 3)` returns 6.
-      """
-    And step "design.gate.answer" changes nothing
-    And step "seam.check" changes nothing
-
-  Scenario: a rebuild stopped at its context limit lands its snapshot and is continued on the branch
-    Given step "seam.naive" writes "src/ops.ts" with:
-      """
-      export const subtract = (a: number, b: number) => a - b
-      export const multiply = (a: number, b: number) => a * b
-      """
-    And step "seam.naive" writes "tests/calc.test.ts" with:
-      """
-      it("adds", () => {})
-      it("[AC-1] subtracts", () => {})
-      it("[AC-2] multiplies", () => {})
-      """
-    And judge step "seam.judge" answers:
-      """
-      [{"id":"shape","answer":"refactor-first","p":0.9}]
-      """
-    And step "implement.building" writes "tests/calc.test.ts" with:
-      """
-      it("adds", () => {})
-      it("[AC-1] subtracts", () => {})
-      """
-    And step "implement.building" writes ".gtd/HANDOFF.md" with:
-      """
-      Rebuilt subtract behind the flag; multiply was next.
-      """
-    When the process is driven
-    Then the process rests at "implement.continue.building"
-    And the resting step's content contains "Still open: AC-2."
-    And the resting step's content contains "Its work is already in the tree."
-    And the resting step's content contains "Delete `.gtd/HANDOFF.md` once you are done"
-    And "tests/calc.test.ts" contains "[AC-1] subtracts"
-
-    Given step "implement.continue.building" writes "tests/calc.test.ts" with:
-      """
-      it("adds", () => {})
-      it("[AC-1] subtracts", () => {})
-      it("[AC-2] multiplies", () => {})
-      """
-    And step "implement.continue.building" deletes ".gtd/HANDOFF.md"
-    When the process is driven
-    Then the process rests at "implement.health.check"
-    And the commit subjects end with:
-      """
-      gtd(agent): implement.building → implement.continue.building
-      gtd(agent): implement.continue.building → implement.health.check
-      """
-