@pmelab/gtd 18.1.0 → 20.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "18.1.0",
+  "version": "20.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": {
@@ -8,7 +8,7 @@
   },
   "exports": {
     "./flows": "./src/flows/index.ts",
-    "./workflow": "./src/workflows/unified.ts"
+    "./workflow": "./src/workflows/bundled.ts"
   },
   "files": [
     "dist/",
@@ -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

@@ -11,33 +11,38 @@ description: >-
 # Authoring a gtd workflow
 
 A gtd workflow is **plain async TypeScript**: a `gtd.config.ts` at the
-repository root default-exports the **flow**, one async function that awaits
-**steps** built from `@pmelab/gtd/flows`; optional `defaults` (process
-settings), `envDefaults` (environment settings), `summary`, `base` and
-`steering` (steering file → mode, for the LSP) exports sit beside it, and any
-other export is a helper gtd ignores. Every step is a commit; gtd finds where a
-process rests by **replaying** the flow over the episode's commits, so the git
-history IS the state and nothing is stored anywhere else.
+repository root exports **workflows** — every exported async function is one,
+named by its export, awaiting **steps** built from `@pmelab/gtd/flows`; the
+`default` export is the ordinary start. Optional reserved exports (`defaults`
+process settings, `envDefaults` environment settings, `summary`, `base`,
+`steering`, `skills`, `doors`) are shared by the file's workflows. **Never
+export a helper function you do not want startable** — it becomes a workflow.
+Every step is a commit; gtd finds where a process rests by **replaying** the
+flow over the episode's commits, so the git history IS the state and nothing is
+stored anywhere else.
 
 Your job is to produce or edit that module so it loads cleanly and does what the
 user wants. Driving a workflow once it exists is a separate concern — that is
 what a driver does.
 
 **Trust:** gtd evaluates `gtd.config.ts` on every command that resolves workflow
-state (`gtd next` and `gtd lsp` included). It is code the user's repository
-runs; write it with the same care as a build script.
+state (`gtd next`, `gtd lsp`, `gtd door` and `gtd doors` included). It is code
+the user's repository runs; write it with the same care as a build script.
 
 ## Golden rule: start from the bundled default, edit incrementally
 
 Do **not** write a workflow from a blank page unless the user wants something
-tiny. gtd ships one known-good workflow and runs it when no `gtd.config.ts` is
-found, and publishes it as `@pmelab/gtd/workflow`: its default export is that
-flow, and every phase and single step it is built from is a named export. Start
-by importing what you keep and writing only what changes:
+tiny. gtd ships three startable workflows (`feature`, `review`, `fix`) as named
+exports of `@pmelab/gtd/workflow` and runs them when no `gtd.config.ts` is
+found. Its default export is `feature` (the ordinary start), and every phase and
+single step they are built from is a named export too. Start by importing what
+you keep and writing only what changes. Import phases by name; **never
+`export *` from it** — every exported function of your file would become a
+startable workflow:
 
 ```ts
 import { start } from "@pmelab/gtd/flows"
-import bundled, { afterTail, buildTail } from "@pmelab/gtd/workflow"
+import { afterTail, buildTail, feature } from "@pmelab/gtd/workflow"
 
 export {
   defaults,
@@ -45,14 +50,20 @@ export {
   summary,
   base,
   steering,
+  skills,
 } from "@pmelab/gtd/workflow"
 
-export default async ({ entry }) =>
-  entry === "hotfix"
-    ? afterTail(await buildTail(true, start()))
-    : bundled({ entry })
+export default feature
+
+export async function hotfix() {
+  return afterTail(await buildTail(true, start()))
+}
+
+export const doors = { hotfix: { workflow: "hotfix" } }
 ```
 
+`gtd --workflow hotfix` (or `gtd door hotfix`) starts it.
+
 To change a phase itself, read its source in the npm package
 (`node_modules/@pmelab/gtd/src/workflows/`, or under `$(npm root -g)` for a
 global install) and write your own version in `gtd.config.ts`, reusing its
@@ -63,9 +74,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`,
+`buildTail`, and single steps like `triage` or `fixCheck`. 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.
@@ -132,13 +143,14 @@ the pending landing — call it right after the step whose turn you reject.
 - An episode ends when the flow returns or calls `restart()`; the next starts at
   the flow's first step on an ordinary start — that step is where a finished
   process waits (the bundled one is `human("idle", …)`).
-- `gtd --entry <name>` starts a process with the flow's `{ entry }` argument set
-  to `<name>` (`undefined` on an ordinary start). Branch on it, and `refuse()`
-  names you don't accept; a flow that never reads `entry` accepts none. An
-  `export const base = (entry, vars) => commitish | undefined` fixes an entered
-  process's diff base. `--var <name>=<value>` only pins process settings: names
-  the workflow's `defaults` or `.gtdrc` `vars:` declare — never an environment
-  setting.
+- `gtd --workflow <name>` starts a process on the exported workflow `<name>` (an
+  unknown name is a usage error); `gtd door <name> [args]` starts one through a
+  `doors` entry `{ workflow, args?, vars? }` (`gtd doors` lists them; bundled:
+  `fix`, `review [base]`; yours merge over them). An
+  `export const base = (workflow, vars) => commitish | undefined` fixes a
+  started process's diff base (blank = default-branch merge-base).
+  `--var <name>=<value>` only pins process settings: names the workflow's
+  `defaults` or `.gtdrc` `vars:` declare — never an environment setting.
 
 ## Landing rules you are designing for
 
@@ -212,7 +224,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 +241,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/runtime.ts

@@ -259,7 +259,7 @@ export const changesSince = (hash: string, pattern?: string): Changes => {
 /** The commit the process stands on at this point of the flow. */
 export const head = (): string => ctx().head()
 
-/** The process's diff base: the commit before it began, or the base `gtd --entry` fixed. */
+/** The process's diff base: the commit before it began, or the base `gtd --workflow` fixed. */
 export const start = (): string => ctx().start()
 
 /** The skill list `localName` (scoped from here, same as `agent()`) resolves to — for a prompt preamble. */
@@ -348,17 +348,8 @@ export const openQuestions = (text: string): readonly OpenQuestion[] => ctx().op
 
 // ── The workflow ────────────────────────────────────────────────────────────
 
-export interface FlowArgs {
-  /** The name `gtd --entry <name>` started the process with; `undefined` for an ordinary start. */
-  readonly entry: string | undefined
-}
-
-/**
- * A workflow's one flow. A flow that never reads `entry` accepts no
- * `--entry`; one that does decides for itself which names it honours,
- * `refuse()`-ing the rest.
- */
-export type Flow = (args: FlowArgs) => Promise<void>
+/** A workflow's one flow. */
+export type Flow = () => Promise<void>
 
 export interface SummaryContext {
   readonly entryCommit: string
@@ -375,11 +366,25 @@ export interface SummaryContext {
 export type Summary = (context: SummaryContext) => string
 
 /**
- * A workflow module's optional `base` export: the commitish that fixes the
- * diff base of a process `gtd --entry <entry>` starts, or `undefined` for
- * none. Runs when the process is entered, with the vars `--var` sets.
+ * A workflow file's optional `base` export: the commitish that fixes the diff
+ * base of a process `gtd --workflow <workflow>` starts, or `undefined` for
+ * none. Runs when the process is started, with the vars `--var` sets.
  */
-export type EntryBase = (
-  entry: string,
+export type WorkflowBase = (
+  workflow: string,
   vars: Readonly<Record<string, string>>,
 ) => string | undefined
+
+/** A named shortcut: `gtd door <name> [args…]` starts `workflow` with the positional args mapped to process settings. */
+export interface Door {
+  readonly workflow: string
+  /** Static, so `gtd doors --json` can list them. */
+  readonly args?: readonly { readonly name: string; readonly optional?: boolean }[]
+  /** A pure function of the args: no git runs at declaration time. */
+  readonly vars?: (
+    args: Readonly<Record<string, string | undefined>>,
+  ) => Readonly<Record<string, string>>
+}
+
+/** A workflow module's reserved `doors` export. */
+export type Doors = Readonly<Record<string, Door>>

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

@@ -1,8 +1,8 @@
 import { describe, expect, it } from "vitest"
 import { access } from "./access.js"
-import { unified } from "./index.js"
+import { bundled as workflow } from "./index.js"
 
-const { defaults } = unified
+const { defaults } = workflow
 
 const bundled = access(defaults)
 
@@ -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": {},
@@ -35,7 +34,7 @@ describe("the bundled workflow's access export", () => {
   })
 
   it("keys only scopes that run a turn (every key is a skills key)", () => {
-    const known = Object.keys(unified.skills(defaults))
+    const known = Object.keys(workflow.skills(defaults))
     for (const key of Object.keys(bundled)) expect(known).toContain(key)
   })
 })

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/{unified.ts → bundled.ts}

@@ -2,30 +2,30 @@ import {
   changes,
   head,
   human,
-  refuse,
   requireRevert,
   restoreScript,
   revertScript,
   run,
   start,
-  type EntryBase,
-  type FlowArgs,
+  type Doors,
+  type WorkflowBase,
   type Summary,
 } from "../flows/index.js"
 import { baseline, gate } from "./health.js"
 import { packages } from "./packages.js"
-import { architecturePass, design } from "./planning.js"
+import { architecture, design } from "./planning.js"
+import type { FrozenScenarios } from "./scenarios.js"
 import { buildTail, type ReviewOutcome } from "./review.js"
 import { ARCHITECTURE, FEEDBACK, REQUIREMENTS, REVIEW } from "./steps.js"
 import * as t from "./text.js"
 
-// gtd's built-in default workflow. Any change to the tree starts a process:
+// gtd's bundled workflows. Any change to the tree starts a process:
 // `idle` → `unwind` reverts the sketch (its intent survives in history) → a
 // green-baseline gate → design, architecture and one package per concern →
 // the quality lap → human review, which signs off (the episode ends back at
-// `idle`) or sends a full re-plan lap. `--entry fix-precheck`, `--entry
-// review-gate.check --var reviewBase=<commitish>` and `--entry
-// start-gate.check` enter the same flow further in.
+// `idle`) or sends a full re-plan lap. `feature` is that ordinary start;
+// `gtd --workflow fix` and `gtd --workflow review --var reviewBase=<commitish>`
+// enter the same build tail further in.
 //
 // Every part is exported for other workflows to compose; see the modules
 // re-exported below.
@@ -39,6 +39,7 @@ export * from "./steps.js"
 export * from "./health.js"
 export * from "./planning.js"
 export * from "./packages.js"
+export * from "./scenarios.js"
 export * from "./review.js"
 
 /** Revert the sketch that started the process out of the working tree; its intent survives in history. */
@@ -70,11 +71,13 @@ 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 architecturePass()
-    await packages()
-    const outcome = await buildTail(false, base)
+    await architecture()
+    const built = await packages(carried)
+    carried = built.frozen
+    const outcome = await buildTail(false, base, built)
     if (outcome.verdict === "signoff") return
     await reUnwind(outcome)
     base = outcome.base
@@ -103,30 +106,34 @@ export const ordinaryStart = async (): Promise<void> => {
   await planAndBuild(start())
 }
 
-const ENTRIES = ["fix-precheck", "review-gate.check", "start-gate.check"]
+/** Repair a red baseline through the build tail, as its own reviewed commit. */
+export const fix = async (): Promise<void> => {
+  if (await baseline("fix-precheck")) return
+  return afterTail(await buildTail(true, start()))
+}
 
-export default async function unified({ entry }: FlowArgs): Promise<void> {
-  if (entry === undefined) return ordinaryStart()
-  if (entry === "fix-precheck") {
-    if (await baseline("fix-precheck")) return
-    return afterTail(await buildTail(true, start()))
-  }
-  if (entry === "review-gate.check") {
-    await gate("review-gate", t.reviewGateBlockedMessage())
-    return afterTail(await buildTail(false, start()))
-  }
-  if (entry === "start-gate.check") {
-    await gate("start-gate", t.startGateBlockedMessage())
-    return planAndBuild(start())
-  }
-  refuse(
-    `"${entry}" is not an enterable state — enterable states:\n${ENTRIES.map((name) => `  ${name}`).join("\n")}`,
-  )
+/** Pure review of everything since `reviewBase`. */
+export const review = async (): Promise<void> => {
+  await gate("review-gate", t.reviewGateBlockedMessage())
+  return afterTail(await buildTail(false, start()))
 }
 
+export const feature = ordinaryStart
+
+export default feature
+
 export const summary: Summary = t.summaryPrompt
 
 export const steering = { [REQUIREMENTS]: "qa", [ARCHITECTURE]: "qa", [REVIEW]: "review" }
 
-export const base: EntryBase = (entry, vars) =>
-  entry === "review-gate.check" ? (vars.reviewBase ?? "") : undefined
+export const base: WorkflowBase = (workflow, vars) =>
+  workflow === "review" ? (vars.reviewBase ?? "") : undefined
+
+export const doors: Doors = {
+  fix: { workflow: "fix" },
+  review: {
+    workflow: "review",
+    args: [{ name: "base", optional: true }],
+    vars: ({ base }) => (base === undefined ? {} : { reviewBase: base }),
+  },
+}

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/index.ts

@@ -1 +1 @@
-export * as unified from "./unified.js"
+export * as bundled from "./bundled.js"