@pmelab/gtd 28.2.0 → 29.0.0

package/src/workflow-kit/review.ts

@@ -9,7 +9,13 @@ import {
   requireThreadsClosed,
   type Change,
 } from "../flows/index.js"
-import { reviewNotes, reviewRisks, stripCodeThreads, type ReviewNote } from "../steering/index.js"
+import {
+  parseThreads,
+  reviewNotes,
+  reviewRisks,
+  stripCodeThreads,
+  type ReviewNote,
+} from "../steering/index.js"
 
 /** How a review round ended. `feedback` carries what the human edited, for the re-unwind to undo. */
 export type ReviewOutcome =
@@ -24,6 +30,15 @@ export type ReviewOutcome =
       readonly edited: readonly Change[]
     }
 
+export type CollectRound = "reply" | "edits" | "notes" | "triaged"
+
+/** What a round asked to change: the notes judged `edit` and the code paths the human hand-edited. */
+export interface Requested {
+  /** Empty on a hand-edit round: that path runs no triage. */
+  readonly notes: readonly ReviewNote[]
+  readonly paths: readonly string[]
+}
+
 export type Verdict = "edit" | "question" | "nit" | "praise" | "defer"
 
 export type ReviewRisk = ReturnType<typeof reviewRisks>[number]
@@ -44,7 +59,7 @@ export interface ReviewPolicy {
   /** The round at commit `round` left no `file`. */
   readonly reviewMissing: (round: string) => Promise<void>
   /** Turn the round `capture` describes into `feedback`, or change nothing. */
-  readonly collecting: (capture: string) => Promise<void>
+  readonly collecting: (capture: string, round: CollectRound) => Promise<void>
   /** One verdict per note, keyed by note id; a note without one is an edit. */
   readonly triage: (notes: readonly ReviewNote[]) => Promise<ReadonlyMap<string, Verdict>>
   readonly answerQuestions: (notes: readonly ReviewNote[]) => Promise<void>
@@ -55,7 +70,8 @@ export interface ReviewPolicy {
   readonly close: (round: string) => Promise<void>
   /** What a collecting turn reads. */
   readonly captures: {
-    readonly edits: (round: string) => string
+    /** `from` set: the hand-edits landed in an earlier commit than `round`, so name the range. */
+    readonly edits: (round: string, from?: string) => string
     readonly notes: (round: string) => string
     readonly editNotes: (
       round: string,
@@ -68,24 +84,56 @@ export interface ReviewPolicy {
     readonly deleted: string
     /** The collecting turn changed something without writing `feedback`. */
     readonly unmatched: string
+    /**
+     * The collecting turn changed nothing though the round carried an `edit`
+     * note or a code hand-edit. Absent: that round signs off.
+     */
+    readonly dropped?: (requested: Requested) => string
   }
 }
 
-const collect = async (p: ReviewPolicy, capture: string): Promise<"signoff" | "feedback"> => {
-  await p.collecting(capture)
+const collect = async (
+  p: ReviewPolicy,
+  capture: string,
+  round: CollectRound,
+  requested?: Requested,
+): Promise<"signoff" | "feedback"> => {
+  await p.collecting(capture, round)
   if (read(p.feedback) !== undefined) return "feedback"
-  if (changes().length === 0) return "signoff"
+  if (changes().length === 0) {
+    if (
+      p.refusals.dropped !== undefined &&
+      requested !== undefined &&
+      requested.notes.length + requested.paths.length > 0
+    )
+      return refuse(p.refusals.dropped(requested))
+    return "signoff"
+  }
   return refuse(p.refusals.unmatched)
 }
 
-/** A review with ticks, footnote markers and thread definitions removed: what is left is line notes. */
-const notesOf = (text: string): string =>
-  text
-    .replace(/^\[\^[^\]]+\]:[^\n]*(\n(?: {2,}|\t)[^\n]*|\n(?=\s*\n(?: {2,}|\t)))*/gm, "")
-    .replace(/\[\^[^\]]+\]/g, "")
-    .replace(/\[x\]/gi, "[ ]")
-    .replace(/\s+/g, " ")
-    .trim()
+const escapeRe = (s: string): string => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+
+/**
+ * A review with ticks and THREAD footnotes (definition plus markers) removed:
+ * what is left is line notes and one-shot footnotes, which the triage judges.
+ */
+const notesOf = (text: string): string => {
+  let out = text
+  for (const { name } of parseThreads(text)) {
+    const n = escapeRe(name)
+    out = out
+      .replace(
+        new RegExp(
+          `^\\[\\^${n}\\]:[^\\n]*(\\n(?: {2,}|\\t)[^\\n]*|\\n(?=\\s*\\n(?: {2,}|\\t)))*`,
+          "gim",
+        ),
+        "",
+      )
+      .replace(new RegExp(`\\[\\^${n}\\]`, "gi"), "")
+  }
+  return out.replace(/\[x\]/gi, "[ ]").replace(/\s+/g, " ").trim()
+}
 
 /**
  * The human gate and its reply rounds: a question gets an answer inside
@@ -108,7 +156,7 @@ const converse = async (
     }
     requireThreadsClosed(p.file)
     if (!hasThreadFor("agent", p.file)) return collectedAt
-    await p.collecting(p.captures.edits(head()))
+    await p.collecting(p.captures.edits(head()), "reply")
     collectedAt = head()
     requireReplies(p.file)
     if (!hasThreadFor("human", p.file)) return collectedAt
@@ -152,7 +200,12 @@ export const routeNotes = async (
   if (deferred.length > 0) await p.defer(deferred)
   if (edits.length > 0) {
     await r.close()
-    return r.outcome(await collect(p, p.captures.editNotes(r.round, edits, answeredAt)))
+    return r.outcome(
+      await collect(p, p.captures.editNotes(r.round, edits, answeredAt), "triaged", {
+        notes: edits,
+        paths: [],
+      }),
+    )
   }
   if (nits.length > 0) {
     await r.close()
@@ -196,6 +249,28 @@ const settledAfter = (
     !notedSince(p, collectedAt),
 })
 
+const finishNotes = async (
+  p: ReviewPolicy,
+  before: string,
+  reopened: boolean,
+  ctx: Parameters<typeof routeNotes>[2],
+): Promise<Finish> => {
+  // An unchanged review file has no baseline entry, which would read as all-new.
+  const notes = reviewNotes(before, read(p.file) ?? "")
+  if (notes.length > 0) return routeNotes(p, notes, ctx)
+  if (reopened) return ctx.unfolded()
+  await ctx.close()
+  return ctx.outcome(await collect(p, p.captures.notes(ctx.round), "notes"))
+}
+
+const toOutcome = (
+  verdict: "signoff" | "feedback",
+  rest: { base: string; restoreFrom: string; edited: ReadonlyArray<Change> },
+): ReviewOutcome => (verdict === "signoff" ? { verdict } : { verdict, ...rest })
+
+const isReopened = (p: ReviewPolicy, r: { settled: boolean; folded: boolean }): boolean =>
+  r.settled && !r.folded && p.refusals.dropped !== undefined
+
 const finish = async (
   p: ReviewPolicy,
   reviewed: string,
@@ -206,29 +281,37 @@ const finish = async (
   const round = head()
   const since = changesSince(reviewed)
   const edited = since.filter((c) => isCodeEdit(p, c))
-  const baselineText = since.get(p.file)?.before ?? ""
-  const record = read(p.file) ?? ""
   const { folded, settled } = afterCollect(p, collectedAt)
   // The review gate clears every tick before its commit, so a changed
   // review file is a note, never a tick.
   const noted = since.some((c) => c.path === p.file)
   const close = (): Promise<void> => p.close(round)
   const outcome = (verdict: "signoff" | "feedback"): ReviewOutcome =>
-    verdict === "signoff" ? { verdict } : { verdict, base: round, restoreFrom: reviewed, edited }
+    toOutcome(verdict, { base: round, restoreFrom: reviewed, edited })
   const unfolded = async (): Promise<Finish> => {
     await close()
     return outcome(folded ? "feedback" : "signoff")
   }
 
-  const collectWith = async (capture: string): Promise<Finish> => {
+  // Thread-only edits settled the round, but a change note or hand-edit since
+  // `reviewed` must still reach a collecting turn when a dropped edit is refused.
+  const reopened = isReopened(p, { settled, folded })
+  if ((settled && !reopened) || (edited.length === 0 && !noted)) return unfolded()
+  if (edited.length > 0) {
     await close()
-    return outcome(await collect(p, capture))
+    return outcome(
+      await collect(p, p.captures.edits(round, reopened ? reviewed : undefined), "edits", {
+        notes: [],
+        paths: edited.map((c) => c.path),
+      }),
+    )
   }
-  if (settled || (edited.length === 0 && !noted)) return unfolded()
-  if (edited.length > 0) return collectWith(p.captures.edits(round))
-  const notes = reviewNotes(baselineText, record)
-  if (notes.length === 0) return collectWith(p.captures.notes(round))
-  return routeNotes(p, notes, { round, close, outcome, unfolded })
+  return finishNotes(p, since.get(p.file)?.before ?? "", reopened, {
+    round,
+    close,
+    outcome,
+    unfolded,
+  })
 }
 
 /** Write the review; if it marks risks, fix them, keep green, and write it again — once, so the re-review's own risks reach the human unfixed. */

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

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest"
-import { testRepo } from "../../testkit/index.js"
+import { runsItsScript, testRepo, type Actor } from "../../testkit/index.js"
 import { CONFIG_SCAFFOLD } from "../../install/index.js"
 import { reviewDoc } from "../shared/config.fixture.js"
 
@@ -30,3 +30,315 @@ describe("an ordinary feature start", () => {
     expect(repo.subjects()).toEqual(["chore: initial commit"])
   })
 })
+
+const review = (text?: string): string =>
+  [
+    "# Review: abc1234",
+    "",
+    "<!-- base: 0000000 -->",
+    "",
+    "## calc",
+    "",
+    "- [ ] ./src/calc.ts#1-1",
+    text === undefined ? "  add" : "  add[^why]",
+    ...(text === undefined ? [] : ["", "[^why]:", `    - H: ${text}`]),
+    "",
+  ].join("\n")
+
+const CALC = "export const add = (a: number, b: number) => a + b\n"
+
+const naivePlanned = (flag: "0" | "1") => {
+  const repo = testRepo({
+    workflow: CONFIG_SCAFFOLD,
+    env: { GTD_QUALITYREVIEWS: "", GTD_FLAG_NAIVE_PASS: flag, GTD_FLAG_RISK_TIER: "0" },
+  })
+  repo.write("src/calc.ts", CALC)
+  repo.commit("feat: add calculator")
+  repo.write("TODO.md", "# Add subtract\n")
+  return repo
+}
+
+describe("planAndBuild on the naive pass", () => {
+  it("after land, feedback rests next at design.triage, then implement.building, never seam.naive", async () => {
+    const repo = naivePlanned("1")
+    const requirements = (_: unknown, r: typeof repo) =>
+      r.write(
+        ".gtd/REQUIREMENTS.md",
+        "# Requirements\n\n## Concerns\n\n### Subtract\n\n- `subtract`\n",
+      )
+    const lap = {
+      unwind: () => undefined,
+      "start-gate.check": () => undefined,
+      "design.triage": requirements,
+      "design.gate.answer": () => undefined,
+      "seam.naive": (_: unknown, r: typeof repo) => r.write("src/calc.ts", `${CALC}// naive\n`),
+      "seam.judge": () => '[{"id":"shape","answer":"land","p":0.9}]',
+      "implement.building": (_: unknown, r: typeof repo) =>
+        r.write("src/calc.ts", `${CALC}// built\n`),
+      "implement.health.check": () => undefined,
+      "implement.closing": runsItsScript,
+      "build.review.reviewing": (_: unknown, r: typeof repo) => r.write(".gtd/REVIEW.md", review()),
+    }
+    expect((await repo.drive(lap)).state).toBe("build.review.await-review")
+
+    repo.write(".gtd/REVIEW.md", review("also export multiply"))
+    await repo.land()
+    const collected = await repo.drive({
+      "build.review.collecting": (_, r) => {
+        requirements(_, r)
+        r.write(".gtd/REVIEW.md", `${review("also export multiply")}    - A: noted.\n`)
+      },
+    })
+    expect(collected.state).toBe("build.review.await-review")
+
+    repo.write(".gtd/REVIEW.md", review())
+    await repo.land()
+    const rest = await repo.drive({
+      "build.review.closing": runsItsScript,
+      "re-unwind": runsItsScript,
+      "design.triage": (_, r) => r.write(".gtd/REQUIREMENTS.md", "# Requirements\n\n- multiply\n"),
+      "design.gate.answer": () => undefined,
+    })
+    expect(rest.state).toBe("implement.building")
+    expect(rest.content).toContain("already exists")
+    expect(rest.content).not.toContain("write the change fresh")
+    const subjects = repo.subjects()
+    const reUnwind = subjects.findIndex((subject) => subject.endsWith("→ re-unwind"))
+    expect(reUnwind).toBeGreaterThan(-1)
+    expect(subjects.slice(reUnwind + 1).some((subject) => subject.includes("seam."))).toBe(false)
+    expect(subjects.filter((subject) => subject.includes("→ seam.naive"))).toHaveLength(1)
+  })
+})
+
+describe("planAndBuild without the naive pass", () => {
+  it("runs the design → architecture path: no seam, no implement", async () => {
+    const repo = naivePlanned("0")
+    const rest = await repo.drive({
+      unwind: () => undefined,
+      "start-gate.check": () => undefined,
+      "design.triage": (_, r) => r.write(".gtd/REQUIREMENTS.md", "# Requirements\n"),
+      "design.gate.answer": () => undefined,
+    })
+    expect(rest.state).toBe("architecture.author")
+    expect(repo.subjects().some((subject) => /seam|implement/.test(subject))).toBe(false)
+  })
+})
+
+describe("afterTail feedback lap", () => {
+  const TAIL = [
+    `import { start } from "@pmelab/gtd/flows"`,
+    `import { afterTail, buildTail, gate } from "@pmelab/gtd/workflows"`,
+    `export { feature as default, defaults, envDefaults, summary, base, steering, skills, access } from "@pmelab/gtd/workflows"`,
+    `export async function tail() {`,
+    `  await gate("review-gate", "The baseline is red.")`,
+    `  return afterTail(await buildTail(false, start()))`,
+    `}`,
+  ].join("\n")
+
+  const prompts: string[] = []
+
+  const feedbackLap = async (flag: "0" | "1") => {
+    prompts.length = 0
+    const repo = testRepo({
+      workflow: TAIL,
+      env: { GTD_QUALITYREVIEWS: "", GTD_FLAG_NAIVE_PASS: flag, GTD_FLAG_RISK_TIER: "0" },
+    })
+    repo.write("src/calc.ts", CALC)
+    repo.commit("feat: add calculator")
+    await repo.start("tail", "--var", `reviewBase=${repo.hashes()[0]}`)
+    await repo.drive({
+      "review-gate.check": () => undefined,
+      "build.health.check": () => undefined,
+      "build.review.reviewing": (beat, r) => {
+        prompts.push(beat.content)
+        r.write(".gtd/REVIEW.md", review())
+      },
+    })
+    repo.write(".gtd/REVIEW.md", review("also export multiply"))
+    await repo.land()
+    await repo.drive({
+      "build.review.collecting": (_, r) => {
+        r.write(".gtd/REQUIREMENTS.md", "# Requirements\n\n- multiply\n")
+        r.write(".gtd/REVIEW.md", `${review("also export multiply")}    - A: noted.\n`)
+      },
+    })
+    repo.write(".gtd/REVIEW.md", review())
+    await repo.land()
+    return repo
+  }
+
+  const afterFeedback = {
+    "build.review.closing": runsItsScript,
+    "re-unwind": runsItsScript,
+    "design.triage": (_: unknown, r: ReturnType<typeof testRepo>) =>
+      r.write(".gtd/REQUIREMENTS.md", "# Requirements\n\n- multiply, designed\n"),
+    "design.gate.answer": () => undefined,
+  }
+
+  it("flag_naive_pass=1 rests at design.triage, then implement.building, reaching no seam step", async () => {
+    const repo = await feedbackLap("1")
+    expect(
+      (await repo.drive({ "build.review.closing": runsItsScript, "re-unwind": runsItsScript }))
+        .state,
+    ).toBe("design.triage")
+    const rest = await repo.drive(afterFeedback)
+    expect(rest.state).toBe("implement.building")
+    expect(rest.content).toContain("already exists")
+    expect(rest.content).not.toContain("write the change fresh")
+    expect(repo.subjects().some((subject) => subject.includes("seam."))).toBe(false)
+  })
+
+  it("flag_naive_pass=0 re-plans through architecture and packages", async () => {
+    const repo = await feedbackLap("0")
+    const rest = await repo.drive(afterFeedback)
+    expect(rest.state).toBe("architecture.author")
+  })
+
+  it.each(["0", "1"] as const)(
+    "flag_naive_pass=%s: the first review says everything since base, the one after feedback only what is new",
+    async (flag) => {
+      const repo = await feedbackLap(flag)
+      expect(prompts[0]).toContain("it covers everything since the base")
+      expect(prompts[0]).not.toContain("only what is new since the previous review")
+      const writes: Record<string, () => [string, string]> = {
+        "design.triage": () => [".gtd/REQUIREMENTS.md", "# Requirements\n\n- multiply, designed\n"],
+        "implement.building": () => ["src/calc.ts", `${CALC}// again\n`],
+        "packages.item.building": () => ["src/calc.ts", `${CALC}// package\n`],
+        "architecture.author": () => [".gtd/ARCHITECTURE.md", "# Architecture\n\nmultiply\n"],
+        "architecture.decompose.decomposing": () => [
+          ".gtd/packages/01-multiply.md",
+          "# 01 multiply\n",
+        ],
+      }
+      const actors = new Proxy({} as Record<string, Actor>, {
+        get: (_, state: string): Actor | undefined =>
+          state === "build.review.await-review" || state === "idle"
+            ? undefined
+            : (beat, r) => {
+                if (state === "build.review.reviewing") {
+                  prompts.push(beat.content)
+                  r.write(".gtd/REVIEW.md", review())
+                } else if (writes[state]) r.write(...writes[state]())
+                else if (state.endsWith("closing") || state === "re-unwind")
+                  r.runScript(beat.content)
+              },
+      })
+      await repo.drive(actors, { maxBeats: 80 })
+      expect(prompts[1]).toContain("it covers only what is new since the previous review")
+      expect(prompts[1]).not.toContain("everything since the base")
+    },
+  )
+})
+
+describe("an in-flight 28.0.0 naive-pass process", () => {
+  type Edge = readonly [actor: string, from: string, to: string, trailer?: string]
+  const verdict = (answer: string) => `Gtd-Judge: {"id":"shape","answer":"${answer}","p":0.9}`
+  const approved = 'Gtd-Approved: {"step":"seam.approve#1","name":"Test","email":"test@test.com"}'
+  const building: readonly Edge[] = [
+    ["agent", "implement.building", "implement.health.check"],
+    ["check", "implement.health.check", "implement.closing"],
+    ["check", "implement.closing", "build.review.reviewing"],
+    ["agent", "build.review.reviewing", "build.review.await-review"],
+  ]
+  const feedback: readonly Edge[] = [
+    ["human", "build.review.await-review", "build.review.collecting"],
+    ["agent", "build.review.collecting", "build.review.await-review"],
+    ["human", "build.review.await-review", "build.review.closing"],
+    ["check", "build.review.closing", "re-unwind"],
+    ["check", "re-unwind", "design.triage"],
+    ["agent", "design.triage", "design.gate.answer"],
+    ["human", "design.gate.answer", "implement.building"],
+  ]
+  const trails: Record<string, readonly Edge[]> = {
+    land: [["judge", "seam.judge", "implement.building", verdict("land")], ...building],
+    "land, then a feature feedback lap": [
+      ["judge", "seam.judge", "implement.building", verdict("land")],
+      ...building,
+      ...feedback,
+    ],
+    "rejected twice, steered, then landed": [
+      ["judge", "seam.judge", "seam.naive", verdict("reject")],
+      ["agent", "seam.naive", "seam.judge"],
+      ["judge", "seam.judge", "seam.naive", verdict("reject")],
+      ["agent", "seam.naive", "seam.judge"],
+      ["judge", "seam.judge", "seam.steer", verdict("reject")],
+      ["human", "seam.steer", "seam.naive"],
+      ["agent", "seam.naive", "seam.judge"],
+      ["judge", "seam.judge", "implement.building", verdict("land")],
+      ...building,
+    ],
+    "refactor-first": [
+      ["judge", "seam.judge", "seam.approve", verdict("refactor-first")],
+      ["human", "seam.approve", "refactor.deriving", approved],
+      ["check", "refactor.deriving", "refactor.building"],
+      ["agent", "refactor.building", "refactor.health.check"],
+      ["check", "refactor.health.check", "refactor.closing"],
+      ["check", "refactor.closing", "implement.building"],
+      ...building,
+    ],
+  }
+
+  const writeEdgeFiles = (
+    repo: { write: (path: string, content: string) => void },
+    from: string,
+    to: string,
+  ) => {
+    if (from === "seam.steer") repo.write(".gtd/REQUIREMENTS.md", "# Requirements\n\n- steered\n")
+    if (from === "build.review.reviewing") repo.write(".gtd/REVIEW.md", review())
+    if (to === "build.review.collecting")
+      repo.write(".gtd/REVIEW.md", review("also export multiply"))
+    if (from === "build.review.collecting") {
+      repo.write(".gtd/REVIEW.md", `${review("also export multiply")}    - A: noted.\n`)
+      repo.write(".gtd/REQUIREMENTS.md", "# Requirements\n\n- multiply\n")
+    }
+    if (to === "build.review.closing") repo.write(".gtd/REVIEW.md", review())
+  }
+
+  /** The repo at the judge's rest, then `trail` forged edge by edge as `Gtd-Step:` commits. */
+  const forged = async (trail: readonly Edge[], upTo: number) => {
+    const repo = naivePlanned("1")
+    await repo.drive({
+      unwind: () => undefined,
+      "start-gate.check": () => undefined,
+      "design.triage": (_, r) =>
+        r.write(".gtd/REQUIREMENTS.md", "# Requirements\n\n## Concerns\n\n### S\n\n- `s`\n"),
+      "design.gate.answer": () => undefined,
+      "seam.naive": (_, r) => r.write("src/calc.ts", `${CALC}// naive\n`),
+    })
+    const kept = /Gtd-Kept: (\w+)/.exec(repo.messages().at(-1)!)![1]!
+    const seen: Record<string, number> = {
+      "seam.naive": 1,
+      "design.triage": 1,
+      "design.gate.answer": 1,
+    }
+    for (const [actor, from, to, trailer] of trail.slice(0, upTo)) {
+      seen[from] = (seen[from] ?? 0) + 1
+      writeEdgeFiles(repo, from, to)
+      repo.commit(
+        [
+          `gtd(${actor}): ${from} → ${to}`,
+          "",
+          `Gtd-Step: ${from}#${seen[from]}`,
+          ...(trailer === undefined ? [] : [trailer]),
+          ...(actor === "agent" && from === "seam.naive" ? [`Gtd-Kept: ${kept}`] : []),
+          "Gtd-Format: 1",
+        ].join("\n"),
+      )
+    }
+    return repo
+  }
+
+  for (const [name, trail] of Object.entries(trails)) {
+    const replays = name !== "refactor-first"
+    it(`${name}: ${replays ? "every rest replays to itself" : "every rest from the verdict on fails replay"}`, async () => {
+      for (let upTo = 1; upTo <= trail.length; upTo++) {
+        const rest = trail[upTo - 1]![2]
+        const repo = await forged(trail, upTo)
+        if (replays) expect((await repo.next()).state, rest).toBe(rest)
+        else {
+          await expect(repo.next(), rest).rejects.toThrow("the workflow changed under this process")
+        }
+      }
+    })
+  }
+})

package/src/workflows/feature/feature.ts

@@ -1,23 +1,13 @@
-import {
-  changes,
-  head,
-  human,
-  requireRevert,
-  restoreScript,
-  revertScript,
-  run,
-  start,
-  vars,
-} from "../../flows/index.js"
+import { changes, head, human, revertScript, run, slice, start, vars } from "../../flows/index.js"
 import { gate } from "../shared/health.js"
 import { shipped } from "../shared/options.js"
-import { FEEDBACK, REVIEW } from "../shared/steps.js"
+import { FEEDBACK } from "../shared/steps.js"
 import { refusePendingHandOff } from "../shared/tail.js"
 import * as t from "../shared/text.js"
 import { packages } from "./packages.js"
 import { architecture, design } from "./planning.js"
-import { buildTail, type ReviewOutcome } from "./review.js"
-import { seamBuild } from "./seam.js"
+import { buildTail, reUnwind, type ReviewOutcome } from "./review.js"
+import { implement, seamBuild } from "./seam.js"
 import { recordRisk, riskTierOn } from "./tier.js"
 
 // The ordinary start. Any change to the tree starts a process: `idle` →
@@ -34,49 +24,64 @@ export const unwind = (): Promise<void> => {
   })
 }
 
-/**
- * Undo the human's review-round code edits. A path changed since the human
- * left it is not overwritten; requireRevert names it instead.
- */
-export const reUnwind = async (
-  feedback: Extract<ReviewOutcome, { verdict: "feedback" }>,
-): Promise<void> => {
-  const { base, restoreFrom, edited } = feedback
-  const restore = edited.filter((c) => c.status !== "added").map((c) => c.path)
-  const remove = edited.filter((c) => c.status === "added").map((c) => c.path)
-  await run("re-unwind", restoreScript(base, { restore, remove }, restoreFrom), {
-    label: "Re-unwinding your review edit",
-    file: REVIEW,
-    base,
-  })
-  requireRevert(edited, base)
-}
+export { reUnwind }
 
 /** Plan, build and review until a review round signs off; feedback re-plans from scratch. */
-export const planAndBuild = async (firstBase: string): Promise<void> => {
+export const planAndBuild = async (
+  firstBase: string,
+  firstLap: t.ReviewRange = "first",
+): Promise<void> => {
+  // GTD_FLAG_NAIVE_PASS: the record is pinned at the process start, so a mid-process flip never moves a process.
+  if (vars.flag_naive_pass === "1") return naivePlanAndBuild(firstBase)
   let base = firstBase
+  let lap = firstLap
   for (;;) {
     await design(base)
-    const tier = riskTierOn() ? recordRisk() : undefined
-    // GTD_FLAG_NAIVE_PASS: the record is pinned at the process start, so a mid-process flip never moves a process.
-    if (vars.flag_naive_pass === "1") {
-      await seamBuild(tier)
-    } else {
-      await architecture()
-      await packages()
-    }
-    const outcome = await buildTail(false, base, true)
+    await architecture()
+    await packages()
+    const outcome = await buildTail(false, base, true, lap === "first" ? {} : { lap })
     if (outcome.verdict === "signoff") return
     await reUnwind(outcome)
     base = outcome.base
+    lap = "feedback"
+  }
+}
+
+// seam.naive / seam.judge run once: a feedback lap is design → implement on every verdict, so a
+// seam a re-plan turns up is built unjudged and unrefactored.
+const naivePlanAndBuild = async (firstBase: string): Promise<void> => {
+  await design(firstBase)
+  const tier = riskTierOn() ? recordRisk() : undefined
+  const seam = await seamBuild(firstBase)
+  await slice("feature", async () => {
+    await implement(seam.reference, tier)
+    await featureFeedback(
+      await buildTail(false, seam.base, true, { lensBase: seam.base }),
+      seam.base,
+    )
+  })
+}
+
+const featureFeedback = async (first: ReviewOutcome, lensBase?: string): Promise<void> => {
+  let outcome = first
+  while (outcome.verdict === "feedback") {
+    await reUnwind(outcome)
+    await design(outcome.base)
+    const tier = riskTierOn() ? recordRisk() : undefined
+    await implement(undefined, tier, true)
+    outcome = await buildTail(false, outcome.base, true, {
+      lap: "feedback",
+      ...(lensBase === undefined ? {} : { lensBase }),
+    })
   }
 }
 
-/** After a tail that skipped planning: stop on sign-off, re-plan on feedback. */
+/** After a tail that skipped planning: stop on sign-off, re-plan on feedback. Opens no slice: slices cannot nest. */
 export const afterTail = async (outcome: ReviewOutcome): Promise<void> => {
   if (outcome.verdict === "signoff") return
+  if (vars.flag_naive_pass === "1") return featureFeedback(outcome)
   await reUnwind(outcome)
-  await planAndBuild(outcome.base)
+  await planAndBuild(outcome.base, "feedback")
 }
 
 /** An ordinary start: wait at `idle`, unwind the sketch, check the baseline, then plan and build. */

package/src/workflows/feature/one-step-land.feature

@@ -105,4 +105,8 @@ Feature: a naive pass the judge rules land goes straight to implement with no se
     And the commit "gtd(agent): seam.naive → seam.judge" has a body containing "Gtd-Kept:"
     And the commit "gtd(judge): seam.judge → implement.building" has a body containing "\"answer\":\"land\""
     And no commit body contains "Gtd-Approved:"
+    And the output lines of gtd "slices" start with:
+      """
+      feature 
+      """
     And no commit body contains "Gtd-Workflow:"