@pmelab/gtd 38.0.0 → 38.2.0

package/src/workflows/feature/continuation.feature

@@ -0,0 +1,205 @@
+@inmem
+Feature: a turn stopped at its context limit is snapshotted and continued
+
+  A naive pass, refactor or build turn told to stop at its context limit
+  writes its handoff note to `.gtd/HANDOFF.md`. That turn is the snapshot —
+  the naive pass's kept tip, or the refactor's or build's own commit — and a
+  continuation in a fresh conversation (`<phase>.continue.<step>`) picks up
+  from it with the note and what is still open. After `continuations` (3) of
+  them, or `continuationStall` (2) in a row that close nothing still open, the
+  phase rests at `<phase>.oversized`.
+
+  Background:
+    Given the shipped workflows, as gtd install scaffolds them
+    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: a naive pass stopped at its context limit is continued from its kept tip with the open IDs
+    Given step "seam.naive" writes "tests/calc.test.ts" with:
+      """
+      it("[AC-1] subtracts", () => {})
+      """
+    And step "seam.naive" writes ".gtd/HANDOFF.md" with:
+      """
+      Wrote subtract and its test; multiply was next.
+      """
+    When the process is driven
+    Then the process rests at "seam.continue.naive"
+    And the resting step's content contains "Your previous turn stopped at its context limit"
+    And the resting step's content contains "Still open: AC-2."
+    And the resting step's content contains "Wrote subtract and its test; multiply was next."
+    And the resting step's content contains "':(top)' ':(top,exclude).gtd/HANDOFF.md' | git apply"
+    And ".gtd/HANDOFF.md" does not exist
+    And the output of gtd "next --json" contains "\"resume\":false"
+    And the output of gtd "next --json" contains "\"memory\":\"seam.continue#"
+
+    Given step "seam.continue.naive" writes "tests/calc.test.ts" with:
+      """
+      it("[AC-1] subtracts", () => {})
+      it("[AC-2] multiplies", () => {})
+      """
+    When the process is driven
+    Then the process rests at "implement.applying"
+    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.check
+      gtd(check): seam.check → implement.applying
+      """
+
+  Scenario: two continuations in a row that close nothing rest for a person
+    Given step "seam.naive" writes "tests/calc.test.ts" with:
+      """
+      it("[AC-1] subtracts", () => {})
+      """
+    And step "seam.naive" writes ".gtd/HANDOFF.md" with:
+      """
+      Subtract is tested; multiply was next.
+      """
+    And step "seam.continue.naive" writes ".gtd/HANDOFF.md" with:
+      """
+      Still on multiply.
+      """
+    When the process is driven
+    Then the process rests at "seam.oversized"
+    And the resting step's content contains "the last 2 continuations closed nothing still open"
+    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
+      gtd(agent): seam.continue.naive → seam.oversized
+      """
+
+  Scenario: a refactor stopped at its context limit is run green before its continuation
+    Given step "seam.naive" writes "tests/calc.test.ts" with:
+      """
+      it("[AC-1] subtracts", () => {})
+      it("[AC-2] multiplies", () => {})
+      """
+    And step "seam.naive" writes "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => a + b
+      export const subtract = (a: number, b: number) => a - b
+      export const multiply = (a: number, b: number) => a * b
+      """
+    And judge step "seam.judge" answers:
+      """
+      [{"id":"shape","answer":"refactor-first","p":0.9}]
+      """
+    And step "seam.note" writes ".gtd/REFACTOR-NOTE.md" with:
+      """
+      Seam: a shared `op` in src/calc.ts.
+      """
+    And step "refactor.deriving" runs its script
+    And step "refactor.building" writes ".gtd/HANDOFF.md" with:
+      """
+      Started on op; nothing changed yet.
+      """
+    And step "refactor.health.check" changes nothing
+    When the process is driven
+    Then the process rests at "refactor.continue.building"
+    And the resting step's content contains "Still open: src/calc.ts."
+    And the resting step's content contains "Started on op; nothing changed yet."
+    And the commit subjects end with:
+      """
+      gtd(agent): refactor.building → refactor.health.check
+      gtd(check): refactor.health.check → refactor.continue.building
+      """
+
+  Scenario: a refactor continuation that leaves the note in place stopped again
+    Given step "seam.naive" writes "tests/calc.test.ts" with:
+      """
+      it("[AC-1] subtracts", () => {})
+      it("[AC-2] multiplies", () => {})
+      """
+    And step "seam.naive" writes "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => a + b
+      export const subtract = (a: number, b: number) => a - b
+      """
+    And judge step "seam.judge" answers:
+      """
+      [{"id":"shape","answer":"refactor-first","p":0.9}]
+      """
+    And step "seam.note" writes ".gtd/REFACTOR-NOTE.md" with:
+      """
+      Seam: a shared `op` in src/calc.ts.
+      """
+    And step "refactor.deriving" runs its script
+    And step "refactor.building" writes "src/calc.ts" with:
+      """
+      export const op = (a: number, b: number, sign: number) => a + sign * b
+      export const add = (a: number, b: number) => a + b
+      """
+    And step "refactor.building" writes ".gtd/HANDOFF.md" with:
+      """
+      op is in; routing add through it was next.
+      """
+    And step "refactor.health.check" changes nothing
+    And step "refactor.continue.building" writes "src/calc.ts" with:
+      """
+      export const op = (a: number, b: number, sign: number) => a + sign * b
+      export const add = (a: number, b: number) => op(a, b, 1)
+      """
+    When the process is driven
+    Then the process rests at "refactor.continue.building"
+    And the commit subjects end with:
+      """
+      gtd(agent): refactor.building → refactor.health.check
+      gtd(check): refactor.health.check → refactor.continue.building
+      gtd(agent): refactor.continue.building → refactor.health.check
+      gtd(check): refactor.health.check → refactor.continue.building
+      gtd(agent): refactor.continue.building
+      """
+
+  Scenario: once a naive pass has continued, its retry runs in a fresh conversation, not as a continuation
+    Given step "seam.naive" writes "tests/calc.test.ts" with:
+      """
+      it("[AC-1] subtracts", () => {})
+      """
+    And step "seam.naive" writes ".gtd/HANDOFF.md" with:
+      """
+      Multiply was next.
+      """
+    And step "seam.continue.naive" writes "tests/calc.test.ts" with:
+      """
+      it("[AC-1] subtracts", () => {})
+      it("[AC-2] multiplies", () => {})
+      """
+    And step "seam.continue.naive" writes "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => a - b
+      """
+    And judge step "seam.judge" answers:
+      """
+      [{"id":"shape","answer":"reject","p":0.9}]
+      """
+    When the process is driven
+    Then the process rests at "seam.fresh.naive"
+    And the resting step's content contains "rejected"
+    And the output of gtd "next --json" contains "\"resume\":false"

package/src/workflows/feature/criteria.ts

@@ -189,3 +189,14 @@ export const skipDesign = (stated: StatedCriteria | undefined): Promise<boolean>
         })
         return true
       })
+
+/** After a gate that invites narrowing the requirements: an edit must leave valid criteria. */
+export const requireCriteriaIfEdited = (): void => {
+  const change = changes().get(REQUIREMENTS)
+  if (change === undefined) return
+  if (change.status === "deleted")
+    refuse(
+      `gtd land: criteria-missing: ${REQUIREMENTS} must stay — narrow its criteria, never delete it`,
+    )
+  requireCriteria(REQUIREMENTS)
+}

package/src/workflows/feature/refactor.ts

@@ -15,8 +15,9 @@ import {
 } from "../../flows/index.js"
 import { lensEntriesOf } from "../../workflow-kit/index.js"
 import { markFenced } from "../shared/fences.js"
+import { continuing, phase, type Phase } from "../shared/continuation.js"
 import { healthy, type Guard } from "../shared/health.js"
-import { coder, FEEDBACK, REFACTOR } from "../shared/steps.js"
+import { coder, FEEDBACK, HANDOFF, REFACTOR } from "../shared/steps.js"
 import * as t from "../shared/text.js"
 import { defaults, testFileGlobs } from "../shared/vars.js"
 import { buildTail, reUnwind, type FeedbackTarget } from "./review.js"
@@ -263,7 +264,12 @@ const guardOf =
   }
 
 /** Derive, build, check and close one refactor lap; `feedback` is the collected review text of the lap before. */
-const refactorLap = async (p: Plan, guard: Guard, feedback?: string): Promise<void> => {
+const refactorLap = async (
+  p: Plan,
+  guard: Guard,
+  refactor: Phase,
+  feedback?: string,
+): Promise<void> => {
   const { pattern, strays, reference, note } = p
   await run(
     "deriving",
@@ -276,32 +282,59 @@ const refactorLap = async (p: Plan, guard: Guard, feedback?: string): Promise<vo
     ]),
     { label: "Deriving the refactor package", file: REFACTOR_PACKAGE },
   )
-  await t.agentWithSkills(
-    "building",
-    t.refactorBuildingPrompt({
-      pkg: REFACTOR_PACKAGE,
-      strays,
-      pattern,
-      reference,
-      feedback: feedback !== undefined,
-      note: note !== undefined,
-    }),
-    { label: "Refactoring", model: coder(), system: t.builderSystem() },
-  )
-  guard()
-  await healthy(
-    async () => {
-      await t.agentWithSkills("fix.suite.fixing", t.refactorFixPrompt(strays, pattern), {
-        label: "Fixing the check",
-        file: FEEDBACK,
-        model: coder(),
-        system: t.builderSystem(),
-      })
-      guard()
-    },
-    { describeGuard: guard, rules: t.refactorRules(strays, pattern) },
-  )
-  await run("closing", removeScript([REFACTOR_PACKAGE]), { label: "Closing out the refactor" })
+  const reached = new Set<string>()
+  // Each snapshot is greened before its continuation: every sub-step keeps the old suite green.
+  await continuing(refactor, async (from, fresh) => {
+    await fresh(() =>
+      t.agentWithSkills(
+        "building",
+        t.refactorBuildingPrompt({
+          pkg: REFACTOR_PACKAGE,
+          strays,
+          pattern,
+          reference,
+          feedback: feedback !== undefined,
+          note: note !== undefined,
+          from,
+        }),
+        {
+          label: from === undefined ? "Refactoring" : "Continuing the refactor",
+          model: coder(),
+          system: t.builderSystem(),
+        },
+      ),
+    )
+    // Committed by the snapshot, so a turn stopped again may leave it as it was: present means stopped.
+    const left = read(HANDOFF)
+    guard()
+    const snapshot = head()
+    // The building turns' own changes only: a fix turn reaching a path is not the refactor reaching it.
+    for (const c of changes()) reached.add(c.path)
+    await healthy(
+      async () => {
+        await t.agentWithSkills("fix.suite.fixing", t.refactorFixPrompt(strays, pattern), {
+          label: "Fixing the check",
+          file: FEEDBACK,
+          model: coder(),
+          system: t.builderSystem(),
+        })
+        guard()
+      },
+      { describeGuard: guard, rules: t.refactorRules(strays, pattern) },
+    )
+    if (left === undefined) return { result: undefined }
+    return {
+      result: undefined,
+      handoff: {
+        snapshot,
+        note: left.trim(),
+        open: strays.filter((path) => !reached.has(path)),
+      },
+    }
+  })
+  await run("closing", removeScript([REFACTOR_PACKAGE, HANDOFF]), {
+    label: "Closing out the refactor",
+  })
 }
 
 const strayAccess = (strays: readonly string[]) => ({
@@ -315,7 +348,7 @@ export const refactorFirst = async (
   const p = plan(shape, options)
   if (p === undefined) return false
   return scope({ name: "refactor", access: strayAccess(p.strays) }, async () => {
-    await refactorLap(p, guardOf(p, head()))
+    await refactorLap(p, guardOf(p, head()), phase("refactor"))
     return true
   })
 }
@@ -342,9 +375,10 @@ export const reviewedRefactor = async (
         "gtd land: refactor-feedback: the review feedback changed files but wrote no .gtd/REFACTOR.md — a refactor cannot act on it; revert the change, or `gtd abandon` and restart",
       dropped: t.refactorDroppedRefusal,
     }
+    const refactor = phase("refactor")
     let collected: string | undefined
     for (;;) {
-      await refactorLap(p, guard, collected)
+      await refactorLap(p, guard, refactor, collected)
       // A person's edit at an escalation rest is never refused, as in the lap.
       const outcome = await buildTail(entry, {
         green: true,

package/src/workflows/feature/seam.ts

@@ -18,13 +18,15 @@ import {
   run,
   scope,
   slice as sliced,
+  start,
   vars,
   wrote,
   type Change,
   type DiffShapeResult,
   type KeptTip,
 } from "../../flows/index.js"
-import { coder, FEEDBACK, REFACTOR_NOTE, REQUIREMENTS, SLICES } from "../shared/steps.js"
+import { continuing, phase, type Handoff, type Phase } from "../shared/continuation.js"
+import { coder, FEEDBACK, HANDOFF, REFACTOR_NOTE, REQUIREMENTS, SLICES } from "../shared/steps.js"
 import * as t from "../shared/text.js"
 import { defaults } from "../shared/vars.js"
 import { green, requireCoverage } from "./coverage.js"
@@ -32,6 +34,7 @@ import {
   criterionIds,
   requireCriteria,
   requireCriteriaFrozen,
+  requireCriteriaIfEdited,
   sliceIds,
   type CriteriaSlice,
 } from "./criteria.js"
@@ -60,14 +63,47 @@ export const judgeSeam = (tip: KeptTip): Promise<DiffShapeResult> =>
     exempt: tip.changes.filter((c) => c.status === "added").map((c) => c.path),
   })
 
-export const naivePass = (retry?: t.NaiveRetry, slice?: CriteriaSlice): Promise<void> =>
-  t.agentWithSkills("naive", t.naivePassPrompt(retry, sliceIds(slice)), {
-    label: retry === undefined ? "Writing the naive pass" : "Rewriting the naive pass",
+export const naivePass = (
+  retry?: t.NaiveRetry,
+  slice?: CriteriaSlice,
+  from?: Handoff,
+): Promise<void> =>
+  t.agentWithSkills("naive", t.naivePassPrompt(retry, sliceIds(slice), from), {
+    label:
+      from !== undefined
+        ? "Continuing the naive pass"
+        : retry === undefined
+          ? "Writing the naive pass"
+          : "Rewriting the naive pass",
     keep: true,
     model: coder(),
     system: t.builderSystem(),
   })
 
+const handoffOf = (tip: KeptTip, slice: CriteriaSlice | undefined): Handoff | undefined => {
+  const note = tip.changes.find((c) => c.path === HANDOFF && c.after !== undefined)
+  if (note === undefined) return undefined
+  return {
+    snapshot: tip.hash,
+    note: note.after!.trim(),
+    open: unnamed(idsOf(REQUIREMENTS, slice), acceptanceTests(tip.changes)),
+  }
+}
+
+/** A naive pass, continued until a pass ends without a handoff note: the snapshot is its kept tip. */
+const naiveContinued = (
+  retry: t.NaiveRetry | undefined,
+  slice: CriteriaSlice | undefined,
+  naive: Phase,
+) =>
+  continuing(naive, async (from, fresh) => {
+    const tip = await fresh(async () => {
+      await naivePass(retry, slice, from)
+      return kept("naive")!
+    })
+    return { result: tip, handoff: handoffOf(tip, slice) }
+  })
+
 // Only a string an import, `require` or `mock` call takes: a URL route or path-like data is not one.
 const IMPORTED = /(?:\bfrom|\bimport|\brequire\s*\(|\bmock\s*\()\s*\(?\s*(["'`])([^"'`\n]+)\1/g
 const EXTENSION = /\.[\w-]+$/
@@ -258,6 +294,56 @@ const applied = async (tip: string): Promise<boolean> => {
   return !wrote(FEEDBACK) && codeChanges().length > 0
 }
 
+/** `carried` limited to the criteria `.gtd/REQUIREMENTS.md` lists now; a file listing none narrows nothing. */
+const settled = (
+  carried: readonly string[] | undefined,
+  slice: CriteriaSlice | undefined,
+): readonly string[] => {
+  const listed = idsOf(REQUIREMENTS, slice)
+  if (carried === undefined) return listed
+  return listed.length === 0 ? carried : carried.filter((id) => listed.includes(id))
+}
+
+// A snapshot lands on the branch as it is; the health loop greens the whole build after.
+// Open IDs count every test line since the process start, so an amend lap's earlier tests close theirs.
+const build = (options: ImplementOptions): Promise<void> =>
+  continuing(phase("build", requireCriteriaIfEdited), async (from, fresh) => {
+    await fresh(() =>
+      t.agentWithSkills(
+        "building",
+        t.implementBuildingPrompt(
+          options.reference,
+          options.tier,
+          options.amend,
+          options.afterRefactor,
+          flagModeOn(),
+          options.rebuild,
+          sliceIds(options.slice),
+          from,
+        ),
+        {
+          label: from === undefined ? "Implementing" : "Continuing the implementation",
+          model: coder(),
+          system: t.builderSystem(),
+          ...(options.afterRefactor === true ? { allowEmpty: true } : {}),
+        },
+      ),
+    )
+    requireCriteriaFrozen(REQUIREMENTS)
+    // Committed by the snapshot, so a turn stopped again may leave it as it was: present means stopped.
+    const note = read(HANDOFF)
+    if (note === undefined) return { result: undefined }
+    const ids = settled(options.rebuild?.acceptance?.ids, options.slice)
+    return {
+      result: undefined,
+      handoff: {
+        snapshot: head(),
+        note: note.trim(),
+        open: unnamed(ids, acceptanceTests(changesSince(start()))),
+      },
+    }
+  })
+
 export function implement(options?: ImplementOptions): Promise<void>
 /** @deprecated Pass `implement({ reference, tier, amend })`. */
 export function implement(
@@ -276,27 +362,11 @@ export function implement(
     const since = head()
     const acceptance = options.rebuild?.acceptance
     const built = options.naive === undefined || !(await applied(options.naive))
-    if (built)
-      await t.agentWithSkills(
-        "building",
-        t.implementBuildingPrompt(
-          options.reference,
-          options.tier,
-          options.amend,
-          options.afterRefactor,
-          flagModeOn(),
-          options.rebuild,
-          sliceIds(options.slice),
-        ),
-        {
-          label: "Implementing",
-          model: coder(),
-          system: t.builderSystem(),
-          ...(options.afterRefactor === true ? { allowEmpty: true } : {}),
-        },
-      )
-    requireCriteriaFrozen(REQUIREMENTS)
-    if (built && acceptance !== undefined) requireAcceptance(acceptance, since)
+    if (built) await build(options)
+    else requireCriteriaFrozen(REQUIREMENTS)
+    // Only the criteria still listed: a person may narrow them at `implement.oversized`.
+    if (built && acceptance !== undefined)
+      requireAcceptance({ ...acceptance, ids: settled(acceptance.ids, options.slice) }, since)
     // Fix turns are held to the carried tests too: deleting a red one must not buy a green suite.
     await green(
       built && acceptance !== undefined ? () => requireAcceptanceKept(acceptance) : undefined,
@@ -311,9 +381,11 @@ export const closeOut = (): Promise<void> => scope("implement", () => closing(fa
 
 /** A slice with `more` after it keeps the criteria and the slicing for the next one. */
 const closing = (more: boolean): Promise<void> =>
-  run("closing", removeScript(more ? [REFACTOR_NOTE] : [REQUIREMENTS, REFACTOR_NOTE, SLICES]), {
-    label: "Closing out the implementation",
-  })
+  run(
+    "closing",
+    removeScript(more ? [REFACTOR_NOTE, HANDOFF] : [REQUIREMENTS, REFACTOR_NOTE, SLICES, HANDOFF]),
+    { label: "Closing out the implementation" },
+  )
 
 interface Decision {
   readonly reference: string
@@ -392,10 +464,10 @@ const ruled = async (tip: KeptTip, again: Vetting["again"]): Promise<Decision |
 const decide = (slice: CriteriaSlice | undefined): Promise<Decision> =>
   scope("seam", async () => {
     const vetting: Vetting = { again: budget(), waived: false }
+    const naive = phase("naive pass", requireCriteriaIfEdited)
     let retry: t.NaiveRetry | undefined
     for (;;) {
-      await naivePass(retry, slice)
-      const tip = kept("naive")!
+      const tip = await naiveContinued(retry, slice, naive)
       const outcome =
         (await vetted(tip, vetting, slice)) ??
         (flagModeOn() ? await ruled(tip, vetting.again) : { reference: tip.hash, tip })

package/src/workflows/shared/continuation.ts

@@ -0,0 +1,92 @@
+import { human, refuse, scope, vars } from "../../flows/index.js"
+import * as t from "./text.js"
+import type { Handoff } from "./text.js"
+import { defaults } from "./vars.js"
+
+export type { Handoff }
+
+export interface Turned<T> {
+  readonly result: T
+  /** Set when the turn wrote a handoff note, i.e. stopped at its context limit. */
+  readonly handoff?: Handoff | undefined
+}
+
+/** Runs a turn's agent step in a conversation of its own, or in the caller's. */
+export type Fresh = <T>(fn: () => Promise<T>) => Promise<T>
+
+/**
+ * One phase's continuations, shared by every `continuing()` call in it (a naive
+ * retry, a refactor lap) so the caps hold per phase. `spent`: once a turn hit
+ * its context limit, resuming that conversation would only hit it again.
+ */
+export interface Phase {
+  readonly name: string
+  spent: boolean
+  count: number
+  stalled: number
+  /** Run after a landing at `oversized`, where a person may narrow the requirements; absent, the gate does not suggest it. */
+  readonly steered?: (() => void) | undefined
+}
+
+export const phase = (name: string, steered?: () => void): Phase => ({
+  name,
+  spent: false,
+  count: 0,
+  stalled: 0,
+  steered,
+})
+
+const own: Fresh = (fn) => fn()
+// Every `scope()` call is a new conversation; the names keep continuations
+// apart in history from later turns of a phase that merely start afresh.
+const continued: Fresh = (fn) => scope("continue", fn)
+const afresh: Fresh = (fn) => scope("fresh", fn)
+
+const setting = (name: "continuations" | "continuationStall", least: number): number => {
+  const raw = vars[name] ?? defaults[name]!
+  const n = Number(raw)
+  if (raw.trim() === "" || !Number.isInteger(n) || n < least)
+    refuse(`gtd: ${name} must be a whole number of at least ${least}, got ${JSON.stringify(raw)}`)
+  return n
+}
+
+/**
+ * Run `turn` until one ends without a handoff note: each stopped turn is picked
+ * up by a continuation in a fresh conversation. Past `continuations` of them in
+ * the phase, or after `continuationStall` in a row that close nothing still
+ * open, the phase rests at `oversized` for a person; landing there grants a new round.
+ */
+export const continuing = async <T>(
+  phase: Phase,
+  turn: (from: Handoff | undefined, fresh: Fresh) => Promise<Turned<T>>,
+): Promise<T> => {
+  const cap = setting("continuations", 0)
+  const stall = setting("continuationStall", 1)
+  let last = await turn(undefined, phase.spent ? afresh : own)
+  while (last.handoff !== undefined) {
+    phase.spent = true
+    const from = last.handoff
+    if (phase.count >= cap || phase.stalled >= stall) {
+      await human("oversized", {
+        message: t.oversizedMessage(
+          phase.name,
+          from,
+          phase.count >= cap ? { cap } : { stall },
+          phase.steered !== undefined,
+        ),
+        label: "Too big for its context",
+        acceptClean: true,
+      })
+      phase.steered?.()
+      phase.count = 0
+      phase.stalled = 0
+    }
+    last = await turn(from, continued)
+    phase.count++
+    // Nothing countable left open is no stall: only the cap stops such a phase.
+    const closed =
+      from.open.length === 0 || from.open.some((item) => !(last.handoff?.open ?? []).includes(item))
+    phase.stalled = closed ? 0 : phase.stalled + 1
+  }
+  return last.result
+}

package/src/workflows/shared/options.ts

@@ -24,6 +24,8 @@ export const ShippedOptions = Schema.Struct({
   sliceMaxCriteria: setting,
   qualityReviews: setting,
   refactorQualityReviews: setting,
+  continuations: setting,
+  continuationStall: setting,
   testCommand: setting,
   plannerModel: setting,
   coderModel: setting,

package/src/workflows/shared/steps.ts

@@ -15,6 +15,7 @@ export const REFACTOR = ".gtd/REFACTOR.md"
 export const REFACTOR_NOTE = ".gtd/REFACTOR-NOTE.md"
 export const QUALITY = ".gtd/QUALITY.md"
 export const SLICES = ".gtd/SLICES.md"
+export const HANDOFF = ".gtd/HANDOFF.md"
 
 export const planner = (): string => env.plannerModel ?? ""
 export const coder = (): string => env.coderModel ?? ""

package/src/workflows/shared/text.test.ts

@@ -976,7 +976,9 @@ describe("the seam phase's texts", () => {
   it("has a red retry pick up the kept attempt instead of starting over", () => {
     const prompt = renderText(() => naivePassPrompt({ red: "abc123" }))
     expect(prompt).toContain("left the suite red")
-    expect(prompt).toContain("git diff --binary abc123^ abc123 | git apply")
+    expect(prompt).toContain(
+      "git diff --binary --no-color --no-ext-diff --no-textconv abc123^ abc123 | git apply",
+    )
     expect(prompt).toContain(".gtd/FEEDBACK.md")
     expect(prompt).not.toContain("rejected")
   })
@@ -1042,7 +1044,9 @@ describe("the seam phase's texts", () => {
     }
     const prompt = renderText(() => naivePassPrompt(fault))
     expect(prompt).toContain("names AC-2")
-    expect(prompt).toContain("git diff --binary abc123^ abc123 | git apply")
+    expect(prompt).toContain(
+      "git diff --binary --no-color --no-ext-diff --no-textconv abc123^ abc123 | git apply",
+    )
     const message = renderText(() => seamSteerMessage(fault))
     expect(message).toContain("names AC-2")
     expect(message).toContain("`seam.check` runs its suite")