@pmelab/gtd 24.4.0 → 26.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "24.4.0",
+  "version": "26.0.0",
   "private": false,
   "description": "Git-aware CLI that emits the next prompt for an autonomous coding agent based on the current repository state",
   "bin": {
@@ -69,6 +69,7 @@
     "src/cli/",
     "src/edge/",
     "src/emit/",
+    "src/flags/",
     "src/install/",
     "src/platform/",
     "src/replay/",
@@ -106,7 +107,6 @@
     "watch": "tsdown --watch",
     "bench:replay": "node scripts/bench-replay.mjs",
     "test": "turbo run format:check typecheck lint lint:sh lint:boundaries test:unit test:workflows test:e2e:inmem test:e2e:live test:web analyze",
-    "test:fast": "turbo run format:check typecheck lint lint:sh lint:boundaries test:unit test:workflows test:web analyze",
     "test:unit": "vitest run --project unit",
     "test:workflows": "vitest run --project workflows",
     "test:watch": "vitest",

package/src/cli/Cli.test.ts

@@ -23,6 +23,7 @@ import {
   ToolCommands,
 } from "./index.js"
 import { EXIT_CODES, EXIT_RUNTIME_ERROR, EXIT_USAGE_ERROR } from "../wire/index.js"
+import { Host } from "../platform/index.js"
 import { type CommandRequirements } from "./Cli.js"
 import { InMemRepo, testLayers } from "../testkit/index.js"
 import { CONFIG_SCAFFOLD } from "../install/index.js"
@@ -1164,6 +1165,30 @@ describe("runCli — layers() is never invoked for output/usage plans", () => {
   })
 })
 
+describe("runCli — a garbled GTD_FLAG_* value", () => {
+  it("exits 1 naming the variable", async () => {
+    const { io, captured } = capturingIo(
+      () =>
+        Layer.succeed(Host, {
+          root: "/",
+          home: "/",
+          scratchDir: "/",
+          realPath: (p: string) => Effect.succeed(p),
+          env: { GTD_FLAG_BETA: "ture" },
+        }) as unknown as Layer.Layer<CommandRequirements>,
+    )
+    await Effect.runPromise(
+      runCli(["node", "gtd.js", "next"], {
+        ...io,
+        flags: [{ name: "beta", owner: "pmelab", expiry: "2099-01-01", kind: "ops" }],
+      }),
+    )
+    expect(captured().exitCode).toBe(1)
+    expect(captured().stdout).toBe("")
+    expect(captured().stderr).toContain("GTD_FLAG_BETA")
+  })
+})
+
 describe("runCli — exit codes", () => {
   it("output plan: exit is never called (success) — --help and --version still exit 0", async () => {
     const { io, captured } = capturingIo(throwingLayers)

package/src/cli/Cli.ts

@@ -1,6 +1,7 @@
 import { NodeContext } from "@effect/platform-node"
 import { Cause, Effect, Either, Layer } from "effect"
 import {
+  GtdError,
   GtdUsageError,
   Narrator,
   renderFailure,
@@ -9,6 +10,7 @@ import {
   Workspace,
   CommandRunner,
 } from "../platform/index.js"
+import { resolveFlags, type FlagDeclaration } from "../flags/index.js"
 import { GTD_VERSION } from "../install/index.js"
 import {
   ConfigDiscovery,
@@ -1270,6 +1272,8 @@ export interface CliIo {
    * writer when `false`.
    */
   readonly layers: (verbose: boolean) => Layer.Layer<CommandRequirements>
+  /** Test seam: the shipped registry is empty, so a garbled-value test cannot reach the failure path without injecting one. Drop it when the first real flag ships. */
+  readonly flags?: readonly FlagDeclaration[]
 }
 
 // The one write-to-stderr primitive nodeCliIo uses for both `stderr` (errors)
@@ -1403,7 +1407,14 @@ export const runCli = (argv: readonly string[], io: CliIo): Effect.Effect<void,
   }
 
   const out = bufferedArtifactOut(io)
-  return runCommand(plan.command, plan.json, out).pipe(
+  return Effect.flatMap(Host, ({ env }) =>
+    Effect.try({
+      // Validate only: the result is discarded so a garbled value fails before any command runs.
+      try: () => resolveFlags(env, io.flags),
+      catch: (e) => new GtdError((e as Error).message),
+    }),
+  ).pipe(
+    Effect.flatMap(() => runCommand(plan.command, plan.json, out)),
     // `flush()` fires here, on success, BEFORE `io.exit` — the one point
     // where the whole buffered artifact is known-complete and safe to hand
     // to stdout (a failure discards the buffer instead — see

package/src/flags/index.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from "vitest"
+import { FLAGS, resolveFlags, type FlagDeclaration, type Flags } from "./index.js"
+
+const registry = [
+  { name: "alpha", owner: "pmelab", expiry: "2020-01-01", kind: "release" },
+  { name: "new_review", owner: "pmelab", expiry: "2099-01-01", kind: "ops" },
+] as const satisfies readonly FlagDeclaration[]
+
+describe("resolveFlags", () => {
+  it.each(["1", "true", "TRUE", "True"])("%s turns a flag on", (value) => {
+    expect(resolveFlags({ GTD_FLAG_ALPHA: value }, registry).alpha).toBe(true)
+  })
+
+  it.each(["0", "false", "FALSE"])("%s turns a flag off", (value) => {
+    expect(resolveFlags({ GTD_FLAG_ALPHA: value }, registry).alpha).toBe(false)
+  })
+
+  it("reads unset and empty as off, with every declared flag a key", () => {
+    expect(resolveFlags({ GTD_FLAG_NEW_REVIEW: "" }, registry)).toEqual({
+      alpha: false,
+      new_review: false,
+    })
+  })
+
+  it.each(["ture", "constructor", "__proto__", "toString"])(
+    "throws naming the variable, not the value %s",
+    (value) => {
+      expect(() => resolveFlags({ GTD_FLAG_NEW_REVIEW: value }, registry)).toThrow(
+        /^GTD_FLAG_NEW_REVIEW must be 1, 0, true or false$/,
+      )
+    },
+  )
+
+  it("reports the first garbled flag in registry order", () => {
+    expect(() => resolveFlags({ GTD_FLAG_NEW_REVIEW: "x", GTD_FLAG_ALPHA: "y" }, registry)).toThrow(
+      /^GTD_FLAG_ALPHA /,
+    )
+  })
+
+  it("ignores an undeclared GTD_FLAG_* key with a garbled value", () => {
+    expect(() => resolveFlags({ GTD_FLAG_NOPE: "ture" }, registry)).not.toThrow()
+  })
+
+  it("resolves a flag past its expiry like any other", () => {
+    expect(registry[0].expiry < new Date().toISOString().slice(0, 10)).toBe(true)
+    expect(resolveFlags({ GTD_FLAG_ALPHA: "1" }, registry).alpha).toBe(true)
+    expect(resolveFlags({ GTD_FLAG_ALPHA: "0" }, registry).alpha).toBe(false)
+    expect(resolveFlags({}, registry).alpha).toBe(false)
+  })
+
+  it("Flags<R> rejects a misspelt name", () => {
+    const flags: Flags<typeof registry> = resolveFlags({}, registry)
+    // @ts-expect-error misspelt flag name
+    void flags.alpah
+  })
+})
+
+describe("FLAGS", () => {
+  it("declares settable, unique variable names", () => {
+    // Vacuous while FLAGS is empty; guards the first declared flag.
+    const names = (FLAGS as readonly FlagDeclaration[]).map(({ name }) => {
+      expect(name).toMatch(/^[a-z][a-z0-9_]*$/)
+      return name
+    })
+    expect(new Set(names).size).toBe(names.length)
+  })
+})

package/src/flags/index.ts

@@ -0,0 +1,39 @@
+// A flag may change how a step runs, never which step comes next: flags are not recorded in
+// history, so replay must not read them. No lint rule enforces this.
+
+export type FlagKind = "release" | "ops" | "experiment"
+
+export interface FlagDeclaration {
+  readonly name: string
+  readonly owner: string
+  /** ISO `YYYY-MM-DD`; never enforced at runtime. */
+  readonly expiry: string
+  readonly kind: FlagKind
+}
+
+// fallow-ignore-next-line unused-export
+export const FLAGS = [] as const satisfies readonly FlagDeclaration[]
+
+/** A misspelt name is a compile error. */
+export type Flags<R extends readonly FlagDeclaration[] = typeof FLAGS> = {
+  readonly [N in R[number]["name"]]: boolean
+}
+
+const BOOL: Record<string, boolean> = { "": false, "0": false, false: false, "1": true, true: true }
+
+export const resolveFlags = <const R extends readonly FlagDeclaration[] = typeof FLAGS>(
+  env: Readonly<Record<string, string | undefined>>,
+  registry: R = FLAGS as unknown as R,
+): Flags<R> => {
+  const out: Record<string, boolean> = {}
+  for (const { name } of registry) {
+    const variable = `GTD_FLAG_${name.toUpperCase()}`
+    const raw = env[variable] ?? ""
+    const key = raw.toLowerCase()
+    if (!Object.hasOwn(BOOL, key)) {
+      throw new Error(`${variable} must be 1, 0, true or false`)
+    }
+    out[name] = BOOL[key]!
+  }
+  return out as Flags<R>
+}

package/src/replay/Replay.ts

@@ -260,7 +260,8 @@ export const replay = async (input: ReplayInput): Promise<ReplayOutcome> => {
   const treeAt = (hash: string): TreeView | undefined =>
     hash === input.episode.base.hash
       ? input.episode.base.tree
-      : commits.find((c) => c.hash === hash)?.tree
+      : (commits.find((c) => c.hash === hash)?.tree ??
+        (hash === input.start ? input.startTree : undefined))
 
   let cursor = 0
   let pendingUsed = false

package/src/workflow/vars.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, it } from "vitest"
+import { resolveVars } from "./vars.js"
+
+describe("resolveVars — GTD_FLAG_* belongs to feature flags", () => {
+  it.each(["flag_x", "FLAG_X", "Flag_x"])("%s keeps its default with GTD_FLAG_X set", (name) => {
+    expect(resolveVars({ [name]: "off" }, {}, { GTD_FLAG_X: "on" })).toEqual({ [name]: "off" })
+  })
+
+  it.each([
+    ["flags", "GTD_FLAGS"],
+    ["flagship", "GTD_FLAGSHIP"],
+    ["my_flag_x", "GTD_MY_FLAG_X"],
+  ])("%s still takes %s", (name, key) => {
+    expect(resolveVars({ [name]: "off" }, {}, { [key]: "on" })).toEqual({ [name]: "on" })
+  })
+})

package/src/workflow/vars.ts

@@ -13,7 +13,10 @@ export const resolveVars = (
 ): Record<string, string> => {
   const merged = { ...workflowVars, ...entryVars }
   for (const name of Object.keys(merged)) {
-    const value = env[PREFIX + name.toUpperCase()]
+    const key = PREFIX + name.toUpperCase()
+    // GTD_FLAG_* belongs to feature flags; a flag_* setting loses its env override.
+    if (key.startsWith("GTD_FLAG_")) continue
+    const value = env[key]
     if (value !== undefined) merged[name] = value
   }
   return merged

package/src/workflow-kit/scenarios.test.ts

@@ -0,0 +1,116 @@
+import { describe, expect, it } from "vitest"
+import type { Change } from "../flows/index.js"
+import { assertionLines, removedAssertions } from "./scenarios.js"
+
+const scenario = (name: string, ...steps: string[]): string[] => [
+  `  Scenario: ${name}`,
+  ...steps.map((s) => `    ${s}`),
+]
+
+const feature = (...steps: string[]): string =>
+  ["Feature: x", ...scenario("y", ...steps)].join("\n")
+
+const modified = (path: string, before: string, after: string | undefined): Change => ({
+  path,
+  status: after === undefined ? "deleted" : "modified",
+  before,
+  after,
+})
+
+const lost = (path: string, name: string, ...lines: string[]) => ({
+  path,
+  lines: lines.map((line) => ({ scenario: `Scenario: ${name}`, line })),
+})
+
+describe("assertionLines", () => {
+  it("keeps Then lines and their And/But continuations, not Given/When ones", () => {
+    expect(
+      assertionLines(
+        feature(
+          "Given a",
+          "And b",
+          "When c",
+          "Then d",
+          "And e",
+          "| row |",
+          "But f",
+          "When g",
+          "And h",
+        ),
+      ).map((a) => a.line),
+    ).toEqual(["Then d", "And e", "But f"])
+  })
+
+  it("skips doc string content", () => {
+    expect(
+      assertionLines(feature("Then a file with:", '  """', "  Then not a step", '  """')).map(
+        (a) => a.line,
+      ),
+    ).toEqual(["Then a file with:"])
+  })
+
+  it("names the scenario each assertion sits in, through an Examples table", () => {
+    const source = [
+      "Feature: x",
+      ...scenario("a", "Then one"),
+      "  Scenario Outline: b",
+      "    Then <two>",
+      "    Examples:",
+      "      | two |",
+    ].join("\n")
+    expect(assertionLines(source)).toEqual([
+      { scenario: "Scenario: a", line: "Then one" },
+      { scenario: "Scenario Outline: b", line: "Then <two>" },
+    ])
+  })
+})
+
+describe("removedAssertions", () => {
+  it("reports a reworded assertion of an existing scenario", () => {
+    expect(
+      removedAssertions([
+        modified(
+          "a.feature",
+          feature("Given a", "Then it is shown"),
+          feature("Given a", "Then it is displayed"),
+        ),
+      ]),
+    ).toEqual([lost("a.feature", "y", "Then it is shown")])
+  })
+
+  it("ignores reworded Given and When steps and added assertions", () => {
+    expect(
+      removedAssertions([
+        modified(
+          "a.feature",
+          feature("Given a", "Then b"),
+          feature("Given z", "When y", "Then b", "And c"),
+        ),
+      ]),
+    ).toEqual([])
+  })
+
+  it("counts duplicates, so dropping one of two identical lines shows", () => {
+    expect(
+      removedAssertions([modified("a.feature", feature("Then b", "Then b"), feature("Then b"))]),
+    ).toEqual([lost("a.feature", "y", "Then b")])
+  })
+
+  it("reports an assertion that moved to another scenario", () => {
+    const before = ["Feature: x", ...scenario("a", "Then ok"), ...scenario("b", "When c")]
+    const after = ["Feature: x", ...scenario("a", "When d"), ...scenario("b", "When c", "Then ok")]
+    expect(removedAssertions([modified("a.feature", before.join("\n"), after.join("\n"))])).toEqual(
+      [lost("a.feature", "a", "Then ok")],
+    )
+  })
+
+  it("reports every assertion of a deleted file, none of an added one or a non-feature", () => {
+    expect(
+      removedAssertions([
+        modified("gone.feature", feature("Then b"), undefined),
+        { path: "new.feature", status: "added", before: undefined, after: feature("Then c") },
+        modified("a.ts", "Then b", ""),
+      ]),
+    ).toEqual([lost("gone.feature", "y", "Then b")])
+  })
+})

package/src/workflow-kit/scenarios.ts

@@ -1,130 +1,70 @@
-import { head, read } from "../flows/index.js"
+import type { Change } from "../flows/index.js"
 
-/** Mutable: an accepted change moves the snapshot forward. */
-export interface FrozenScenarios {
-  at: string
-  texts: Record<string, string>
-}
-
-const DOC_STRING = /^(\s*)("""|```)/
-
-/**
- * Gherkin wording only: lines trimmed; blank, `#` comment and `@` tag lines
- * dropped — except inside a doc string, whose content is test input: kept
- * whole, indented relative to its opening delimiter (as Gherkin reads it).
- */
-export const scenarioText = (source: string): string => {
-  const out: string[] = []
-  let doc: { readonly indent: number; readonly fence: string } | undefined
-  for (const line of source.split("\n")) {
-    const delimiter = DOC_STRING.exec(line)
-    if (doc === undefined && delimiter !== null) {
-      doc = { indent: delimiter[1]!.length, fence: delimiter[2]! }
-      out.push(line.trim())
-    } else if (doc !== undefined && line.trim().startsWith(doc.fence)) {
-      doc = undefined
-      out.push(line.trim())
-    } else if (doc !== undefined) {
-      const lead = line.length - line.trimStart().length
-      out.push(line.slice(Math.min(lead, doc.indent)).trimEnd())
-    } else {
-      const trimmed = line.trim()
-      if (trimmed !== "" && !trimmed.startsWith("#") && !trimmed.startsWith("@")) out.push(trimmed)
-    }
-  }
-  return out.join("\n")
-}
+const DOC_STRING = /^("""|```)/
+const THEN = /^Then\s/
+const CONTINUATION = /^(And|But|\*)\s/
+const HEADING = /^(Feature|Rule|Background|Scenario|Scenario Outline|Scenario Template|Example):/
 
-const textOf = (path: string): string | undefined => {
-  const source = read(path)
-  return source === undefined ? undefined : scenarioText(source)
+export interface Assertion {
+  /** The trimmed heading line of the scenario (or background) it sits in. */
+  readonly scenario: string
+  readonly line: string
 }
 
-/** Snapshot `.feature` paths at `head()`, merged over `previous`; `undefined` when nothing is frozen. */
-export const freezeScenarios = (
-  paths: readonly string[],
-  previous?: FrozenScenarios,
-): FrozenScenarios | undefined => {
-  if (paths.length === 0) return previous
-  const texts: Record<string, string> = { ...previous?.texts }
-  for (const path of paths) {
-    const text = textOf(path)
-    if (text !== undefined) texts[path] = text
+/** Trimmed lines outside doc strings, whose content is test input, not steps. */
+const stepLines = (source: string): string[] => {
+  const out: string[] = []
+  let fence: string | undefined
+  for (const trimmed of source.split("\n").map((l) => l.trim())) {
+    const opening = fence === undefined ? DOC_STRING.exec(trimmed)?.[1] : undefined
+    if (opening !== undefined) fence = opening
+    else if (fence === undefined) out.push(trimmed)
+    else if (trimmed.startsWith(fence)) fence = undefined
   }
-  return Object.keys(texts).length === 0 ? previous : { at: head(), texts }
+  return out
 }
 
-/** Paths whose wording differs from the snapshot (a deleted file counts). */
-export const driftedScenarios = (frozen: FrozenScenarios): readonly string[] =>
-  Object.entries(frozen.texts)
-    .filter(([path, text]) => textOf(path) !== text)
-    .map(([path]) => path)
-
-// Blank lines survive only inside doc strings, where they are wording.
-const lines = (text: string | undefined): string[] =>
-  text === undefined || text === "" ? [] : text.split("\n")
-
-/** `table[i][j]`: the longest common subsequence of `a[i..]` and `b[j..]`. */
-const lcsTable = (a: readonly string[], b: readonly string[]): number[][] => {
-  const table = Array.from({ length: a.length + 1 }, () => Array<number>(b.length + 1).fill(0))
-  for (let i = a.length - 1; i >= 0; i--) {
-    for (let j = b.length - 1; j >= 0; j--) {
-      table[i]![j] =
-        a[i] === b[j] ? table[i + 1]![j + 1]! + 1 : Math.max(table[i + 1]![j]!, table[i]![j + 1]!)
-    }
-  }
-  return table
-}
+const neutral = (line: string): boolean =>
+  line === "" || line.startsWith("#") || line.startsWith("|")
 
-/** Changed lines in file order, `- ` / `+ `-prefixed, so a moved or repeated step still shows. */
-const lineDiff = (a: readonly string[], b: readonly string[]): string[] => {
-  const table = lcsTable(a, b)
-  const out: string[] = []
-  let i = 0
-  let j = 0
-  while (i < a.length && j < b.length) {
-    if (a[i] === b[j]) {
-      i++
-      j++
-    } else if (table[i + 1]![j]! >= table[i]![j + 1]!) out.push(`- ${a[i++]}`)
-    else out.push(`+ ${b[j++]}`)
+/** Trimmed `Then` step lines, an `And`/`But`/`*` continuing one included; doc strings skipped. */
+export const assertionLines = (source: string): readonly Assertion[] => {
+  const out: Assertion[] = []
+  let inThen = false
+  let scenario = ""
+  for (const line of stepLines(source)) {
+    if (HEADING.test(line)) scenario = line
+    if (THEN.test(line)) inThen = true
+    else if (!CONTINUATION.test(line) && !neutral(line)) inThen = false
+    if (inThen && !neutral(line)) out.push({ scenario, line })
   }
-  return [...out, ...a.slice(i).map((l) => `- ${l}`), ...b.slice(j).map((l) => `+ ${l}`)]
+  return out
 }
 
-export interface WordingDrift {
+export interface RemovedAssertions {
   readonly path: string
-  /** `- `/`+ `-prefixed, in file order. */
-  readonly lines: readonly string[]
+  readonly lines: readonly Assertion[]
 }
 
-export const wordingDrift = (frozen: FrozenScenarios, path: string): WordingDrift => ({
-  path,
-  lines: lineDiff(lines(frozen.texts[path]), lines(textOf(path))),
-})
+const key = (a: Assertion): string => `${a.scenario}\n${a.line}`
 
 /**
- * After a turn: rest at `stop` while wording drifted from `frozen`. Whatever
- * still differs after it is accepted and moves the snapshot; what was
- * restored stays frozen as it was.
+ * Assertions a `.feature` file that existed before `changes` lost — the one
+ * way rewording a scenario can weaken it. Matched within each scenario and
+ * counted, so a line moving to another scenario, or one of two identical
+ * `Then`s dropped, still shows. A renamed scenario reports all of its own.
  */
-export const holdWording = async (
-  frozen: FrozenScenarios | undefined,
-  stop: (at: string, drifted: readonly WordingDrift[]) => Promise<void>,
-): Promise<void> => {
-  if (frozen === undefined) return
-  const drifted = driftedScenarios(frozen)
-  if (drifted.length === 0) return
-  await stop(
-    frozen.at,
-    drifted.map((path) => wordingDrift(frozen, path)),
-  )
-  const accepted = driftedScenarios(frozen)
-  if (accepted.length === 0) return
-  for (const path of accepted) {
-    const text = textOf(path)
-    if (text === undefined) delete frozen.texts[path]
-    else frozen.texts[path] = text
-  }
-  frozen.at = head()
-}
+export const removedAssertions = (changes: readonly Change[]): readonly RemovedAssertions[] =>
+  changes
+    .filter((c) => c.path.endsWith(".feature") && c.before !== undefined)
+    .map((c) => {
+      const left = new Map<string, number>()
+      for (const a of assertionLines(c.after ?? "")) left.set(key(a), (left.get(key(a)) ?? 0) + 1)
+      const lines = assertionLines(c.before ?? "").filter((a) => {
+        const n = left.get(key(a)) ?? 0
+        left.set(key(a), n - 1)
+        return n <= 0
+      })
+      return { path: c.path, lines }
+    })
+    .filter((r) => r.lines.length > 0)

package/src/workflows/feature/feature.ts

@@ -10,7 +10,6 @@ import {
 } from "../../flows/index.js"
 import { gate } from "../shared/health.js"
 import { shipped } from "../shared/options.js"
-import type { FrozenScenarios } from "../shared/scenarios.js"
 import { FEEDBACK, REVIEW } from "../shared/steps.js"
 import { refusePendingHandOff } from "../shared/tail.js"
 import * as t from "../shared/text.js"
@@ -53,13 +52,11 @@ export const reUnwind = async (
 /** Plan, build and review until a review round signs off; feedback re-plans from scratch. */
 export const planAndBuild = async (firstBase: string): Promise<void> => {
   let base = firstBase
-  let carried: FrozenScenarios | undefined
   for (;;) {
     await design(base)
     await architecture()
-    const built = await packages(carried)
-    carried = built.frozen
-    const outcome = await buildTail(false, base, built)
+    await packages()
+    const outcome = await buildTail(false, base, true)
     if (outcome.verdict === "signoff") return
     await reUnwind(outcome)
     base = outcome.base

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

@@ -1,6 +1,6 @@
 import { afterEach, describe, expect, it } from "vitest"
 import { installContext, type Change, type StepRequest } from "../../flows/index.js"
-import { declaredTests, packages, SCENARIO_PACKAGE } from "./packages.js"
+import { declaredTests, packages } from "./packages.js"
 import { fixtureContext } from "../shared/text.fixture.js"
 
 afterEach(() => installContext(undefined))
@@ -41,51 +41,34 @@ describe("declaredTests", () => {
   })
 })
 
-describe("packages scenarios", () => {
-  it("holds only package 0's own paths, not what later packages add", async () => {
-    const queue = [SCENARIO_PACKAGE, ".gtd/packages/01-impl.md"]
-    const touches: { at: number; change: Change }[] = []
-    let steps = 0
-    const touch = (path: string, status: Change["status"]): void => {
-      touches.push({ at: steps, change: { path, status, before: undefined, after: "x" } })
-    }
-    const effects: Record<string, () => void> = {
-      building: () => {
-        if (queue[0] === SCENARIO_PACKAGE) {
-          touch("tests/e2e/a.feature", "added")
-          touch(".gtd/packages/00-e2e-scenarios.md", "modified")
-        } else {
-          touch("src/impl.ts", "added")
-          touch("tests/e2e/b.feature", "added")
-          touch("tests/e2e/a.feature", "modified")
-        }
-      },
-      closing: () => void queue.shift(),
-    }
+describe("packages", () => {
+  it("closes every queued package in name order, the plan with the last", async () => {
+    const queue = [".gtd/packages/02-b.md", ".gtd/packages/01-a.md"]
+    const closings: string[] = []
     installContext(
       fixtureContext(
         {},
         {
           step: (request: StepRequest) => {
-            steps++
-            if (request.kind !== "restart") effects[request.name]?.()
+            if (request.kind === "run" && request.name === "closing") {
+              closings.push(request.body)
+              queue.splice(queue.indexOf([...queue].sort()[0]!), 1)
+            }
             return Promise.resolve()
           },
           pushScope: () => undefined,
           popScope: () => undefined,
-          refuse: (message: string): never => {
-            throw new Error(message)
-          },
           glob: () => [...queue],
-          changesSince: (hash: string): readonly Change[] =>
-            touches.filter((t) => t.at >= Number(hash.slice(1))).map((t) => t.change),
-          head: () => `c${steps}`,
+          changesSince: (): readonly Change[] => [],
+          head: () => "c",
         },
       ),
     )
-    const plan = await packages()
-    expect(plan.ranges.map((r) => r.pkg)).toEqual([SCENARIO_PACKAGE, ".gtd/packages/01-impl.md"])
-    expect(plan.scenarios.added).toEqual(["tests/e2e/a.feature"])
-    expect(plan.scenarios.changed).toEqual([])
+    await packages()
+    expect(closings).toHaveLength(2)
+    expect(closings[0]).toContain("01-a.md")
+    expect(closings[0]).not.toContain("ARCHITECTURE")
+    expect(closings[1]).toContain("02-b.md")
+    expect(closings[1]).toContain(".gtd/ARCHITECTURE.md")
   })
 })