@pmelab/gtd 18.1.0 → 19.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "18.1.0",
+  "version": "19.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": {
@@ -47,6 +47,7 @@
     "watch": "tsdown --watch",
     "bench:replay": "node scripts/bench-replay.mjs",
     "test": "turbo run format:check typecheck lint lint:sh lint:boundaries test:unit test:e2e:inmem test:e2e:live test:web analyze",
+    "test:fast": "turbo run format:check typecheck lint lint:sh lint:boundaries test:unit test:web analyze",
     "test:unit": "vitest run --project unit",
     "test:watch": "vitest",
     "test:changed": "vitest run --project unit --project e2e-inmem --changed HEAD",

package/skills/authoring/SKILL.md

@@ -63,9 +63,9 @@ current directory is the whole workflow. If one already exists, read it and edit
 it in place.
 
 Prefer the bundled workflow's own parts over re-implementing them — `healthy`,
-`escalation`, `gate`, `design`, `architecturePass`, `packages`, `specReview`,
-`qualityLap`, `review`, `buildTail`, and single steps like `triage` or `fix`.
-Their full step names are versioned API.
+`escalation`, `gate`, `design`, `architecture`, `packages`, `qualityLap`,
+`review`, `buildTail`, and single steps like `triage` or `fix`. Their full step
+names are versioned API.
 
 Make one small change, **verify it loads** (see "Verify"), then make the next. A
 workflow that fails to load breaks every gtd command in the repository.
@@ -212,7 +212,7 @@ sign-off between the two:
 const planAndBuild = async (): Promise<void> => {
   for (;;) {
     await design()
-    await architecturePass()
+    await architecture()
     await human("approve-plan", {
       message:
         "The packages under .gtd/packages/ are ready. Edit them to adjust the plan, or change nothing — then run `gtd land` to start building.",
@@ -229,9 +229,8 @@ const planAndBuild = async (): Promise<void> => {
 `acceptClean: true` is what makes an untouched landing approve; without it the
 gate would wait for an edit. `approve-plan` sits in the `root` scope and is a
 new, unique name. Verify: `gtd next` loads without errors, and in a scratch
-repository a landing at `architecture.decompose` (or `architecture-promote`) now
-leads to `approve-plan`, and an untouched landing there to
-`packages.item.building`.
+repository a landing at `architecture.decompose` now leads to `approve-plan`,
+and an untouched landing there to `packages.item.building`.
 
 ## No migration
 

package/src/flows/helpers.ts

@@ -36,6 +36,8 @@ export interface CheckOptions {
   readonly sweep?: readonly string[] | undefined
   /** Paths removed once it passes. */
   readonly sweepOnGreen?: readonly string[] | undefined
+  /** Shell lines run before the command, outside its output capture; an `exit 0` skips it and leaves `report` untouched. */
+  readonly preamble?: readonly string[] | undefined
 }
 
 /**
@@ -48,10 +50,10 @@ export const check = async (
   command: string,
   options: CheckOptions,
 ): Promise<boolean> => {
-  const { report, label, sweep, sweepOnGreen } = options
+  const { report, label, sweep, sweepOnGreen, preamble } = options
   await run(
     name,
-    checkScript(command, { report, stamp: head().slice(0, 7), sweep, sweepOnGreen }),
+    checkScript(command, { report, stamp: head().slice(0, 7), sweep, sweepOnGreen, preamble }),
     { label },
   )
   return !wrote(report)

package/src/flows/scripts.test.ts

@@ -1,5 +1,9 @@
+import { spawnSync } from "node:child_process"
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
 import { describe, expect, it } from "vitest"
-import { restoreScript } from "./scripts.js"
+import { checkScript, restoreScript } from "./scripts.js"
 
 describe("restoreScript", () => {
   const paths = { restore: ["a.ts"], remove: [] }
@@ -14,3 +18,26 @@ describe("restoreScript", () => {
     expect(script).not.toContain("abc~1")
   })
 })
+
+describe("checkScript preamble", () => {
+  const options = { report: ".gtd/FEEDBACK.md", stamp: "abc" }
+  const runIn = (script: string, dir: string): void => {
+    writeFileSync(join(dir, "s.sh"), script)
+    spawnSync("sh", ["s.sh"], { cwd: dir })
+  }
+
+  it("renders before the command subshell", () => {
+    const script = checkScript("npm test", { ...options, preamble: ["echo pre"] })
+    expect(script.indexOf("echo pre")).toBeGreaterThan(-1)
+    expect(script.indexOf("echo pre")).toBeLessThan(script.indexOf("npm test"))
+  })
+
+  it("an exit 0 in the preamble skips the command and leaves report alone", () => {
+    const dir = mkdtempSync(join(tmpdir(), "gtd-pre-"))
+    mkdirSync(join(dir, ".gtd"))
+    writeFileSync(join(dir, ".gtd/FEEDBACK.md"), "old")
+    runIn(checkScript("touch ran", { ...options, preamble: ["exit 0"] }), dir)
+    expect(existsSync(join(dir, "ran"))).toBe(false)
+    expect(readFileSync(join(dir, ".gtd/FEEDBACK.md"), "utf8")).toBe("old")
+  })
+})

package/src/flows/scripts.ts

@@ -14,6 +14,8 @@ export interface CheckScriptOptions {
   readonly sweep?: readonly string[] | undefined
   /** Paths removed once it passes. */
   readonly sweepOnGreen?: readonly string[] | undefined
+  /** Shell lines run before the command, outside its output capture; an `exit 0` skips it and leaves `report` untouched. */
+  readonly preamble?: readonly string[] | undefined
 }
 
 const removal = (paths: readonly string[]): string[] =>
@@ -29,6 +31,7 @@ export const checkScript = (command: string, options: CheckScriptOptions): strin
   return [
     "#!/usr/bin/env sh",
     "set +e",
+    ...(options.preamble ?? []),
     ...removal(options.sweep ?? []),
     `mkdir -p "$(dirname ${report})"`,
     // A subshell, so an `exit` inside the command ends only the command.

package/src/workflows/access.test.ts

@@ -12,7 +12,6 @@ describe("the bundled workflow's access export", () => {
       design: { write: [] },
       architecture: { write: [".gtd/REQUIREMENTS.md"] },
       "architecture.decompose": { write: [".gtd/packages/**", ".gtd/ARCHITECTURE.md"] },
-      "packages.item.spec": { write: [".gtd/SPEC_FEEDBACK.md"] },
       "build.review": { write: [".gtd/REVIEW.md"] },
       "build.review.fix.nits": {},
       "build.review.fix.risks": {},

package/src/workflows/access.ts

@@ -12,7 +12,6 @@ export const access = (
   design: { write: [] },
   architecture: { write: [".gtd/REQUIREMENTS.md"] },
   "architecture.decompose": { write: [".gtd/packages/**", ".gtd/ARCHITECTURE.md"] },
-  "packages.item.spec": { write: [".gtd/SPEC_FEEDBACK.md"] },
   "build.review": { write: [".gtd/REVIEW.md"] },
   // `{}` reopens what `build.review` restricted: the fixes edit code.
   "build.review.fix.nits": {},

package/src/workflows/health.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it } from "vitest"
 import { toRequest } from "../judges/index.js"
-import { retryQuestion } from "./health.js"
+import { fastSuiteGuard, retryQuestion } from "./health.js"
+import { renderText } from "./text.fixture.js"
 
 describe("retryQuestion", () => {
   it.each([true, false])("is sendable to jev (comparable=%s)", (comparable) => {
@@ -11,3 +12,22 @@ describe("retryQuestion", () => {
     ).toBeGreaterThanOrEqual(2)
   })
 })
+
+describe("fastSuiteGuard", () => {
+  it("unset: names the setting and exits 0", () => {
+    const lines = renderText(fastSuiteGuard).join("\n")
+    expect(lines).toContain("fastTestCommand")
+    expect(lines).toContain("GTD_FASTTESTCOMMAND")
+    expect(lines).toContain("exit 0")
+  })
+
+  it("blank after trim counts as unset", () => {
+    expect(renderText(fastSuiteGuard, { env: { fastTestCommand: "  \t " } })).toContain("exit 0")
+  })
+
+  it("set: only removes SETUP", () => {
+    const lines = renderText(fastSuiteGuard, { env: { fastTestCommand: "true" } })
+    expect(lines.join("\n")).not.toContain("exit 0")
+    expect(lines.join("\n")).toContain("rm -f")
+  })
+})

package/src/workflows/health.ts

@@ -1,3 +1,4 @@
+import { dirname } from "node:path"
 import {
   answered,
   check,
@@ -5,6 +6,7 @@ import {
   human,
   judge,
   numeric,
+  quote,
   read,
   scope,
   vars,
@@ -13,12 +15,37 @@ import {
 import { describeEscalation, escalate, escalationExhausted, ESCALATION, FEEDBACK } from "./steps.js"
 import * as t from "./text.js"
 
+/** Written while `fastTestCommand` is unset; its presence rests the process at the check. */
+export const SETUP = ".gtd/SETUP.md"
+
+const SETUP_TEXT =
+  "The bundled workflow needs the `fastTestCommand` setting: the fast suite (everything but e2e).\nSet it under `env:` in `.gtdrc` or as GTD_FASTTESTCOMMAND."
+
+/** Shell lines for a check's preamble: unset (blank after trim) setting writes `SETUP` and skips the suite. */
+export const fastSuiteGuard = (): string[] =>
+  (env.fastTestCommand ?? "").trim() === ""
+    ? [
+        `mkdir -p ${quote(dirname(SETUP))}`,
+        `printf '%s\\n' ${quote(SETUP_TEXT)} > ${quote(SETUP)}`,
+        `printf '%s\\n' ${quote(SETUP_TEXT)} >&2`,
+        "exit 0",
+      ]
+    : [`rm -f ${quote(SETUP)}`]
+
 /** Fix turns a run of red checks gets before it escalates. */
 export const FIX_CAP = 3
 
 /** Run the suite as step `name`; resolves `true` when it passed. A failure is in `.gtd/FEEDBACK.md`. */
-export const baseline = (name: string, label = "Checking the baseline"): Promise<boolean> =>
-  check(name, env.testCommand ?? "", { report: FEEDBACK, label })
+export const baseline = async (name: string, label = "Checking the baseline"): Promise<boolean> => {
+  for (;;) {
+    const green = await check(name, env.testCommand ?? "", {
+      report: FEEDBACK,
+      label,
+      preamble: fastSuiteGuard(),
+    })
+    if (read(SETUP) === undefined) return green
+  }
+}
 
 /** How many escalation rounds a run of red checks has spent — reset once the suite goes green. */
 export interface EscalationCount {
@@ -81,6 +108,21 @@ export interface HealthOptions {
   readonly fixesSoFar?: number
   /** Escalation rounds shared with other callers in the same run of red checks. */
   readonly escalations?: EscalationCount
+  /** `fast` runs `fastTestCommand` (default `full`: `testCommand`). */
+  readonly suite?: "full" | "fast"
+  /** Paths removed on a green run. */
+  readonly sweepOnGreen?: readonly string[]
+}
+
+const runSuite = (options: HealthOptions): Promise<boolean> => {
+  const fast = options.suite === "fast"
+  return check("health.check", (fast ? env.fastTestCommand : env.testCommand) ?? "", {
+    report: FEEDBACK,
+    label: "Running checks",
+    // Swept only on green: an unresolved analysis survives every retry.
+    sweepOnGreen: [ESCALATION, ...(options.sweepOnGreen ?? [])],
+    ...(fast ? { preamble: fastSuiteGuard() } : {}),
+  })
 }
 
 /**
@@ -96,12 +138,9 @@ export const healthy = async (
   let fixes = options.fixesSoFar ?? 0
   let previous: string | undefined
   for (;;) {
-    const green = await check("health.check", env.testCommand ?? "", {
-      report: FEEDBACK,
-      label: "Running checks",
-      // Swept only on green: an unresolved analysis survives every retry.
-      sweepOnGreen: [ESCALATION],
-    })
+    const green = await runSuite(options)
+    // Unconfigured: straight back to the check, no fix turn or count.
+    if (options.suite === "fast" && read(SETUP) !== undefined) continue
     if (green) {
       escalations.rounds = 0
       return

package/src/workflows/packages.test.ts

@@ -0,0 +1,91 @@
+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 { fixtureContext } from "./text.fixture.js"
+
+afterEach(() => installContext(undefined))
+
+describe("declaredTests", () => {
+  it("parses unit and e2e lines of the Tests section", () => {
+    const text = [
+      "# Package",
+      "",
+      "## Tests",
+      "",
+      "- unit: `lib/a.test.ts`",
+      "- e2e: `spec/a.feature`",
+    ].join("\n")
+    expect(declaredTests(text)).toEqual([
+      { level: "unit", path: "lib/a.test.ts" },
+      { level: "e2e", path: "spec/a.feature" },
+    ])
+  })
+
+  it("ignores prose, malformed lines and other sections", () => {
+    const text = [
+      "## Tasks",
+      "- unit: `lib/not-here.test.ts`",
+      "## Tests",
+      "Some prose.",
+      "- unit: lib/unquoted.test.ts",
+      "- integration: `lib/x.test.ts`",
+      "- unit: `lib/ok.test.ts` extra",
+      "## Notes",
+      "- e2e: `spec/other.feature`",
+    ].join("\n")
+    expect(declaredTests(text)).toEqual([{ level: "unit", path: "lib/ok.test.ts" }])
+  })
+
+  it("returns nothing without a Tests section", () => {
+    expect(declaredTests("# Chore\n\n## Tasks\n- do it\n")).toEqual([])
+  })
+})
+
+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(),
+    }
+    installContext(
+      fixtureContext(
+        {},
+        {
+          step: (request: StepRequest) => {
+            steps++
+            if (request.kind !== "restart") effects[request.name]?.()
+            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}`,
+        },
+      ),
+    )
+    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([])
+  })
+})

package/src/workflows/packages.ts

@@ -1,109 +1,129 @@
 import {
-  answered,
-  changes,
   changesSince,
+  type Change,
   glob,
   head,
-  judge,
-  numeric,
   read,
   refuse,
   removeScript,
   run,
   scope,
-  sectionBodies,
-  vars,
-  wrote,
-  type JudgeQuestion,
 } from "../flows/index.js"
-import { packageDiff } from "./diff.js"
 import { healthy } from "./health.js"
-import { ARCHITECTURE, build, fixSpec, fixSuite, reviewPackage, SPEC_FEEDBACK } from "./steps.js"
-import * as t from "./text.js"
+import { freezeScenarios, guarded, type FrozenScenarios } from "./scenarios.js"
+import { build, fixSuite } from "./steps.js"
 
-const MAX_SECTIONS = 8
-const DIFF_KEY = "diff"
+/** Package 0: the e2e scenarios, written red. */
+export const SCENARIO_PACKAGE = ".gtd/packages/00-e2e-scenarios.md"
 
-const sectionQuestion = (id: string, title: string): JudgeQuestion => ({
-  id,
-  primitive: "noul",
-  instructions: `Is the requirement "${title}" — the "${id}" evidence — already fully satisfied by the code in the "${DIFF_KEY}" evidence?`,
-  criteria:
-    "Judge from the requirement text and the diff evidence alone. Only answer yes at a probability clearing the threshold below if genuinely confident nothing in this section is missing.",
-})
+export interface DeclaredTest {
+  readonly level: "unit" | "e2e"
+  readonly path: string
+}
+
+const TEST_LINE = /^\s*-\s+(unit|e2e):\s+`([^`]+)`/
+
+/** The `## Tests` entries of a package file; malformed lines are ignored. */
+export const declaredTests = (packageText: string): readonly DeclaredTest[] => {
+  const found: DeclaredTest[] = []
+  let inTests = false
+  for (const line of packageText.split("\n")) {
+    if (/^##\s/.test(line)) inTests = /^##\s+Tests\s*$/.test(line)
+    else if (inTests) {
+      const match = TEST_LINE.exec(line)
+      if (match) found.push({ level: match[1] as DeclaredTest["level"], path: match[2]! })
+    }
+  }
+  return found
+}
 
 /**
- * Review one freshly built package against its spec: a pre-judge per
- * section, then an agent review of the sections it did not confidently
- * clear. `since` is the commit the package's own build started from — the
- * pre-judge's evidence is a diff over exactly that range, never an earlier
- * package's commits. Resolves `true` when approved.
+ * Refuse a build or fix turn unless every test `pkg` declares exists and is in the
+ * diff since `since`. The package text is read as of `since`, so a builder
+ * editing its own `## Tests` cannot dodge the guard; with `.gtd/SATISFIED.md`
+ * written, existing in the tree suffices.
  */
-export const specReview = async (pkg: string, since: string): Promise<boolean> => {
-  const found = sectionBodies(read(pkg) ?? "")
-  const titles = found.map((section) => section.title)
-  const judged = titles.length > 0 && titles.length <= MAX_SECTIONS
-  const evidence: Record<string, string> = {}
-  const questions: JudgeQuestion[] = []
-  if (judged) {
-    found.forEach(({ title, body }, i) => {
-      evidence[`section-${i + 1}`] = body
-      questions.push(sectionQuestion(`section-${i + 1}`, title))
-    })
-    // The diff's own even share of the budget: one key per section plus
-    // `diff` itself, so this cap equals what `budgeted` gives it below.
-    const capBytes = Math.floor(numeric(vars.judgeBudgetBytes, 32768) / (found.length + 1))
-    evidence[DIFF_KEY] = packageDiff(changesSince(since), capBytes)
-  }
-  const { answers, truncated } = await judge("spec.pre", {
-    questions,
-    evidence,
-    message: t.packagesItemSpecPreMessage(),
-    label: "Judging spec coverage",
-  })
-  // A section is cleared only by a confident yes on evidence that was not
-  // cut — its own body, or the diff every question is judged against.
-  const clearMinP = numeric(vars.specPreJudge, Infinity)
-  const failing = titles.filter((_, i) => {
-    const id = `section-${i + 1}`
-    return (
-      !judged ||
-      truncated.includes(id) ||
-      truncated.includes(DIFF_KEY) ||
-      !answered(answers[id], "yes", clearMinP)
+export const requireDeclaredTests = (pkg: string, since: string): void => {
+  const range = changesSince(since)
+  const text = range.get(pkg)?.before ?? read(pkg) ?? ""
+  const satisfied = read(".gtd/SATISFIED.md") !== undefined
+  const missing = declaredTests(text)
+    .map((test) => test.path)
+    .filter((path) =>
+      satisfied
+        ? read(path) === undefined
+        : range.get(path) === undefined ||
+          range.get(path)?.status === "deleted" ||
+          read(path) === undefined,
     )
-  })
-  if (titles.length > 0 && failing.length === 0) return true
-  await reviewPackage(pkg, failing)
-  if (wrote(SPEC_FEEDBACK)) return false
-  if (changes(SPEC_FEEDBACK).length > 0 || changes().length === 0) return true
-  return refuse(
-    "gtd land: no declared pattern matches the pending changes — write .gtd/SPEC_FEEDBACK.md to request changes, or change nothing to approve",
+  if (missing.length === 0) return
+  refuse(
+    `gtd land: declared-tests: ${pkg} declares tests that are ${satisfied ? "missing from the tree" : "not in the package's diff"} — write them first:\n${missing.map((path) => `  - ${path}`).join("\n")}`,
   )
 }
 
-/** Build `pkg`, keep the suite green, review it against its spec, and close it out, which removes it. */
-export const packageItem = async (pkg: string): Promise<void> => {
-  const since = head()
-  await build(pkg)
-  for (;;) {
-    await healthy(fixSuite)
-    if (await specReview(pkg, since)) break
-    await fixSpec(pkg)
+export interface PackageRange {
+  readonly pkg: string
+  readonly from: string
+  readonly to: string
+}
+
+export interface BuiltPlan {
+  readonly ranges: readonly PackageRange[]
+  /** Paths package 0 added / modified outside `.gtd/`. */
+  readonly scenarios: { readonly added: readonly string[]; readonly changed: readonly string[] }
+  /** The wording snapshot after this run, to guard the tail and later laps. */
+  readonly frozen: FrozenScenarios | undefined
+}
+
+/** Build `pkg`, check its declared tests, keep the fast suite green, and close it out, which removes it. */
+export const packageItem = async (pkg: string, frozen?: FrozenScenarios): Promise<PackageRange> => {
+  const from = head()
+  // Rechecked after every fix too: a fix deleting a red declared test would
+  // otherwise green the suite. Before the wording gate, so it refuses the turn.
+  const declared = (turn: () => Promise<void>) => async () => {
+    await turn()
+    requireDeclaredTests(pkg, from)
   }
-  // The spent technical plan goes with the first package built from it.
-  await run("closing", removeScript([pkg, SPEC_FEEDBACK, ".gtd/SATISFIED.md", ARCHITECTURE]), {
+  await guarded(
+    frozen,
+    declared(() => build(pkg)),
+  )()
+  await healthy(guarded(frozen, declared(fixSuite)), { suite: "fast" })
+  await run("closing", removeScript([pkg, ".gtd/SATISFIED.md"]), {
     label: "Closing out the package",
   })
+  return { pkg, from, to: head() }
 }
 
 /** The first queued package — the one a package step works on. */
 export const nextPackage = (): string | undefined => [...glob(".gtd/packages/*.md")].sort()[0]
 
+const outsideGtd = (path: string): boolean => path !== ".gtd" && !path.startsWith(".gtd/")
+
 /** Build every package file under `.gtd/packages/`, in name order. */
-export const packages = (): Promise<void> =>
+export const packages = (carried?: FrozenScenarios): Promise<BuiltPlan> =>
   scope("packages", async () => {
+    let frozen = carried
+    const ranges: PackageRange[] = []
+    // Captured right after package 0: a later diff to the tree would also hold what 01…N touch.
+    let touched: readonly Change[] = []
     for (let pkg = nextPackage(); pkg !== undefined; pkg = nextPackage()) {
-      await scope("item", () => packageItem(pkg))
+      const range = await scope("item", () =>
+        packageItem(pkg, pkg === SCENARIO_PACKAGE ? undefined : frozen),
+      )
+      ranges.push(range)
+      if (pkg === SCENARIO_PACKAGE) {
+        touched = changesSince(range.from).filter(
+          (c) => outsideGtd(c.path) && c.status !== "deleted",
+        )
+        frozen = freezeScenarios(
+          touched.filter((c) => c.path.endsWith(".feature")).map((c) => c.path),
+          frozen,
+        )
+      }
     }
+    const paths = (status: string): string[] =>
+      touched.filter((c) => c.status === status).map((c) => c.path)
+    return { ranges, scenarios: { added: paths("added"), changed: paths("modified") }, frozen }
   })

package/src/workflows/planning.ts

@@ -1,20 +1,12 @@
 import {
-  answered,
   changes,
   hasThreadFor,
-  judge,
-  moveScript,
-  numeric,
-  read,
   refuse,
   requireAnswers,
   requireReplies,
   requireThreadsClosed,
   requireProgress,
-  run,
   scope,
-  sections,
-  vars,
 } from "../flows/index.js"
 import {
   answerProductQuestions,
@@ -25,7 +17,6 @@ import {
   REQUIREMENTS,
   triage,
 } from "./steps.js"
-import * as t from "./text.js"
 
 /**
  * Always stop for the human. Resolves `true` when the round changed anything
@@ -62,44 +53,9 @@ export const architecture = (): Promise<void> =>
     if (changes(".gtd/packages/**").length === 0) {
       refuse("gtd land: decompose: write at least one package under .gtd/packages/")
     }
+    if (changes(ARCHITECTURE).some((c) => c.status === "deleted")) {
+      refuse(
+        "gtd land: decompose: keep .gtd/ARCHITECTURE.md — the build tail's full run needs it; it is removed only once that run is green",
+      )
+    }
   })
-
-/** A package file name from a plan's first heading. */
-const slug = (title: string): string =>
-  title
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "") || "package"
-
-/** Whether the settled plan needs its own architecture pass, or goes straight to one package. */
-export const architecturePass = async (): Promise<void> => {
-  const { answers, truncated } = await judge("architecture-pre", {
-    questions: [
-      {
-        id: "architectureWarranted",
-        primitive: "noul",
-        instructions:
-          "Given the settled concerns in `.gtd/REQUIREMENTS.md` (in state), does this plan warrant a dedicated architecture pass — real structural decisions, multiple integration points, or a non-obvious tradeoff — before packages are written?",
-        criteria:
-          "Answer yes if uncertain; a trivial, single-concern, mechanical plan with no real design decision answers no.",
-      },
-    ],
-    evidence: { requirements: read(REQUIREMENTS) ?? "" },
-    message: t.architecturePreMessage(),
-    label: "Judging whether this plan warrants an architecture pass",
-  })
-  // A plan the budget cut can hide its structural concerns from the judge:
-  // never skip the architecture pass on it, however confident the "no".
-  const skip =
-    truncated.length === 0 &&
-    answered(answers.architectureWarranted, "no", numeric(vars.architectureSkipMinP, Infinity))
-  const plan = read(REQUIREMENTS)
-  if (skip && plan !== undefined) {
-    const target = `.gtd/packages/01-${slug(sections(plan)[0] ?? "")}.md`
-    await run("architecture-promote", moveScript(REQUIREMENTS, target), {
-      label: "Promoting the plan straight to a package",
-    })
-    return
-  }
-  await architecture()
-}